Mac Easy 2010 May/Mac Life Ubuntu.iso/casper/filesystem.squashfs/usr/share/system-config-printer/system-config-printer.pyc

Python Compiled Bytecode | 2009-10-12 | 177.5 KB | 6,401 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

import config
import errno
import sys
import os
import tempfile
import time
import traceback
import re
import httplib
import glob
import subprocess
import signal
import thread
import dbus

try:
    import gtk.glade as gtk
except RuntimeError:
    e = None
    print 'system-config-printer:', e
    print 'This is a graphical application and requires DISPLAY to be set.'
    sys.exit(1)

import gnome
gtk.about_dialog_set_url_hook((lambda x, y: gnome.url_show(y)))
gtk.about_dialog_set_email_hook((lambda x, y: gnome.url_show('mailto:' + y)))

def show_help():
    print '\nThis is system-config-printer, a CUPS server configuration program.\n\nOptions:\n\n  --setup-printer URI\n            Select the (detected) CUPS device URI on start-up,\n            and run the new-printer wizard for it.\n\n  --configure-printer NAME\n            Select the named printer on start-up, and open its\n            properties dialog.\n\n  --choose-driver NAME\n            Select the named printer on start-up, and display\n            the list of drivers.\n\n  --print-test-page NAME\n            Select the named printer on start-up and print a\n            test page to it.\n\n  --no-focus-on-map\n            Do not focus the main window, to prevent focus \n            stealing\n\n  --debug   Enable debugging output.\n'

if len(sys.argv) > 1 and sys.argv[1] == '--help':
    show_help()
    sys.exit(0)

import cups
cups.require('1.9.42')

try:
    import pysmb
    PYSMB_AVAILABLE = True
except:
    PYSMB_AVAILABLE = False

import cupshelpers
import options
import gobject
from glade import GtkGUI
from optionwidgets import OptionWidget
from debug import *
import probe_printer
import gtk_label_autowrap
from gtk_treeviewtooltips import TreeViewTooltips
import urllib
import troubleshoot
import jobviewer
import authconn
import monitor
from smburi import SMBURI
import errordialogs
from errordialogs import *
import installpackage
import userdefault
from AdvancedServerSettings import AdvancedServerSettingsDialog
from PhysicalDevice import PhysicalDevice
from ToolbarSearchEntry import *
from GroupsPane import *
from GroupsPaneModel import *
from SearchCriterion import *
import gtkinklevel
import pango
import statereason
domain = 'system-config-printer'
import locale

try:
    locale.setlocale(locale.LC_ALL, '')
except locale.Error:
    os.environ['LC_ALL'] = 'C'
    locale.setlocale(locale.LC_ALL, '')

from gettext import gettext as _
monitor.set_gettext_function(_)
errordialogs.set_gettext_function(_)
authconn.set_gettext_function(_)
import gettext
gettext.textdomain(domain)
gettext.bindtextdomain(domain, config.localedir)
gtk.glade.textdomain(domain)
gtk.glade.bindtextdomain(domain, config.localedir)
import ppdippstr
pkgdata = config.pkgdatadir
iconpath = os.path.join(pkgdata, 'icons/')
sys.path.append(pkgdata)
busy_cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
ready_cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
TEXT_start_firewall_tool = _('To do this, select System->Administration->Firewall from the main menu.')

try:
    try_CUPS_SERVER_REMOTE_ANY = cups.CUPS_SERVER_REMOTE_ANY
except AttributeError:
    try_CUPS_SERVER_REMOTE_ANY = '_remote_any'


def validDeviceURI(uri):
    '''Returns True is the provided URI is valid.'''
    (scheme, rest) = urllib.splittype(uri)
    if scheme == None or scheme == '':
        return False
    if rest == None or rest.strip('/') == '':
        return False
    return True


def CUPS_server_hostname():
    host = cups.getServer()
    if host[0] == '/':
        return 'localhost'
    return host


def moveClassMembers(treeview_from, treeview_to):
    selection = treeview_from.get_selection()
    (model_from, rows) = selection.get_selected_rows()
    rows = [ gtk.TreeRowReference(model_from, row) for row in rows ]
    model_to = treeview_to.get_model()
    for row in rows:
        path = row.get_path()
        iter = model_from.get_iter(path)
        row_data = model_from.get(iter, 0)
        model_to.append(row_data)
        model_from.remove(iter)



def getCurrentClassMembers(treeview):
    model = treeview.get_model()
    iter = model.get_iter_root()
    result = []
    while iter:
        result.append(model.get(iter, 0)[0])
        iter = model.iter_next(iter)
    result.sort()
    return result


def on_delete_just_hide(widget, event):
    widget.hide()
    return True


class GUI(GtkGUI, monitor.Watcher):
    printer_states = {
        cups.IPP_PRINTER_IDLE: _('Idle'),
        cups.IPP_PRINTER_PROCESSING: _('Processing'),
        cups.IPP_PRINTER_BUSY: _('Busy'),
        cups.IPP_PRINTER_STOPPED: _('Stopped') }

    def __init__(self, setup_printer = None, configure_printer = None, change_ppd = False, devid = '', print_test_page = False, focus_on_map = True):

        try:
            self.language = locale.getlocale(locale.LC_MESSAGES)
            self.encoding = locale.getlocale(locale.LC_CTYPE)
        except:
            nonfatalException()
            os.environ['LC_ALL'] = 'C'
            locale.setlocale(locale.LC_ALL, '')
            self.language = locale.getlocale(locale.LC_MESSAGES)
            self.encoding = locale.getlocale(locale.LC_CTYPE)

        self.printer = None
        self.conflicts = set()
        if not self.printer or self.printer.getServer():
            pass
        self.connect_server = cups.getServer()
        self.connect_encrypt = cups.getEncryption()
        self.connect_user = cups.getUser()
        self.changed = set()
        self.servers = set((self.connect_server,))
        self.server_is_publishing = False
        self.devid = devid
        self.focus_on_map = focus_on_map
        self.updating_widgets = False
        self.getWidgets({
            'PrintersWindow': [
                'PrintersWindow',
                'view_area_vbox',
                'view_area_scrolledwindow',
                'dests_iconview',
                'statusbarMain',
                'toolbar',
                'server_settings_menu_entry',
                'new_printer',
                'new_class',
                'group_menubar_item',
                'printer_menubar_item',
                'view_discovered_printers',
                'view_groups'],
            'AboutDialog': [
                'AboutDialog'],
            'WaitWindow': [
                'WaitWindow',
                'lblWait'],
            'ConnectDialog': [
                'ConnectDialog',
                'chkEncrypted',
                'cmbServername',
                'btnConnect'],
            'ConnectingDialog': [
                'ConnectingDialog',
                'lblConnecting',
                'pbarConnecting'],
            'NewPrinterName': [
                'NewPrinterName',
                'entCopyName',
                'btnCopyOk'],
            'ServerSettingsDialog': [
                'ServerSettingsDialog',
                'chkServerBrowse',
                'chkServerShare',
                'chkServerShareAny',
                'chkServerRemoteAdmin',
                'chkServerAllowCancelAll',
                'chkServerLogDebug',
                'hboxServerBrowse'],
            'PrinterPropertiesDialog': [
                'PrinterPropertiesDialog',
                'tvPrinterProperties',
                'btnPrinterPropertiesCancel',
                'btnPrinterPropertiesOK',
                'btnPrinterPropertiesApply',
                'btnPrinterPropertiesClose',
                'ntbkPrinter',
                'entPDescription',
                'entPLocation',
                'lblPMakeModel',
                'lblPMakeModel2',
                'lblPState',
                'entPDevice',
                'lblPDevice2',
                'btnSelectDevice',
                'btnChangePPD',
                'chkPEnabled',
                'chkPAccepting',
                'chkPShared',
                'lblNotPublished',
                'btnPrintTestPage',
                'btnSelfTest',
                'btnCleanHeads',
                'btnConflict',
                'cmbPStartBanner',
                'cmbPEndBanner',
                'cmbPErrorPolicy',
                'cmbPOperationPolicy',
                'rbtnPAllow',
                'rbtnPDeny',
                'tvPUsers',
                'entPUser',
                'btnPAddUser',
                'btnPDelUser',
                'lblPInstallOptions',
                'swPInstallOptions',
                'vbPInstallOptions',
                'swPOptions',
                'lblPOptions',
                'vbPOptions',
                'algnClassMembers',
                'vbClassMembers',
                'lblClassMembers',
                'tvClassMembers',
                'tvClassNotMembers',
                'btnClassAddMember',
                'btnClassDelMember',
                'btnRefreshMarkerLevels',
                'tvPrinterStateReasons',
                'ntbkPrinterStateReasons',
                'sbJOCopies',
                'btnJOResetCopies',
                'cmbJOOrientationRequested',
                'btnJOResetOrientationRequested',
                'cbJOFitplot',
                'btnJOResetFitplot',
                'cmbJONumberUp',
                'btnJOResetNumberUp',
                'cmbJONumberUpLayout',
                'btnJOResetNumberUpLayout',
                'sbJOBrightness',
                'btnJOResetBrightness',
                'cmbJOFinishings',
                'btnJOResetFinishings',
                'sbJOJobPriority',
                'btnJOResetJobPriority',
                'cmbJOMedia',
                'btnJOResetMedia',
                'cmbJOSides',
                'btnJOResetSides',
                'cmbJOHoldUntil',
                'btnJOResetHoldUntil',
                'cbJOMirror',
                'btnJOResetMirror',
                'sbJOScaling',
                'btnJOResetScaling',
                'sbJOSaturation',
                'btnJOResetSaturation',
                'sbJOHue',
                'btnJOResetHue',
                'sbJOGamma',
                'btnJOResetGamma',
                'sbJOCpi',
                'btnJOResetCpi',
                'sbJOLpi',
                'btnJOResetLpi',
                'sbJOPageLeft',
                'btnJOResetPageLeft',
                'sbJOPageRight',
                'btnJOResetPageRight',
                'sbJOPageTop',
                'btnJOResetPageTop',
                'sbJOPageBottom',
                'btnJOResetPageBottom',
                'cbJOPrettyPrint',
                'btnJOResetPrettyPrint',
                'cbJOWrap',
                'btnJOResetWrap',
                'sbJOColumns',
                'btnJOResetColumns',
                'tblJOOther',
                'entNewJobOption',
                'btnNewJobOption',
                'vboxMarkerLevels',
                'btnRefreshMarkerLevels'] })
        self.PrintersWindow.set_focus_on_map(self.focus_on_map)
        self.PrintersWindow.show()
        for dialog in [
            self.PrinterPropertiesDialog,
            self.ServerSettingsDialog]:
            dialog.connect('delete-event', on_delete_just_hide)

        self.ConnectingDialog.connect('delete-event', self.on_connectingdialog_delete)
        self.tooltips = gtk.Tooltips()
        self.tooltips.enable()
        gtk.window_set_default_icon_name('printer')
        self.btnNew = gtk.MenuToolButton('gtk-new')
        self.btnNew.set_is_important(True)
        newmenu = gtk.Menu()
        newprinter = gtk.ImageMenuItem(_('Printer'))
        printericon = gtk.Image()
        printericon.set_from_icon_name('printer', gtk.ICON_SIZE_MENU)
        newprinter.set_image(printericon)
        newprinter.connect('activate', self.on_new_printer_activate)
        self.btnNew.connect('clicked', self.on_new_printer_activate)
        newclass = gtk.ImageMenuItem(_('Class'))
        classicon = gtk.Image()
        classicon.set_from_icon_name('gtk-dnd-multiple', gtk.ICON_SIZE_MENU)
        newclass.set_image(classicon)
        newclass.connect('activate', self.on_new_class_activate)
        newprinter.show()
        newclass.show()
        newmenu.attach(newprinter, 0, 1, 0, 1)
        newmenu.attach(newclass, 0, 1, 1, 2)
        self.btnNew.set_menu(newmenu)
        self.toolbar.add(self.btnNew)
        self.toolbar.add(gtk.SeparatorToolItem())
        refreshbutton = gtk.ToolButton('gtk-refresh')
        refreshbutton.connect('clicked', self.on_btnRefresh_clicked)
        self.toolbar.add(refreshbutton)
        self.toolbar.show_all()
        printer_manager_action_group = gtk.ActionGroup('PrinterManagerActionGroup')
        printer_manager_action_group.add_actions([
            ('rename-printer', None, _('_Rename'), None, None, self.on_rename_activate),
            ('copy-printer', gtk.STOCK_COPY, None, '<Ctrl>c', None, self.on_copy_activate),
            ('delete-printer', gtk.STOCK_DELETE, None, None, None, self.on_delete_activate),
            ('set-default-printer', gtk.STOCK_HOME, _('Set As De_fault'), None, None, self.on_set_as_default_activate),
            ('edit-printer', gtk.STOCK_PROPERTIES, None, None, None, self.on_edit_activate),
            ('create-class', gtk.STOCK_DND_MULTIPLE, _('_Create class'), None, None, self.on_create_class_activate),
            ('view-print-queue', gtk.STOCK_FIND, _('View Print _Queue'), None, None, self.on_view_print_queue_activate),
            ('add-to-group', None, _('_Add to Group'), None, None, None),
            ('save-as-group', None, _('Save Results as _Group'), None, None, self.on_save_as_group_activate),
            ('save-as-search-group', None, _('Save Filter as _Search Group'), None, None, self.on_save_as_search_group_activate)])
        printer_manager_action_group.add_toggle_actions([
            ('enable-printer', None, _('E_nabled'), None, None, self.on_enabled_activate),
            ('share-printer', None, _('_Shared'), None, None, self.on_shared_activate)])
        printer_manager_action_group.add_radio_actions([
            ('filter-name', None, _('Name')),
            ('filter-description', None, _('Description')),
            ('filter-location', None, _('Location')),
            ('filter-manufacturer', None, _('Manufacturer / Model'))], 1, self.on_filter_criterion_changed)
        for action in printer_manager_action_group.list_actions():
            action.set_sensitive(False)

        printer_manager_action_group.get_action('view-print-queue').set_sensitive(True)
        printer_manager_action_group.get_action('filter-name').set_sensitive(True)
        printer_manager_action_group.get_action('filter-description').set_sensitive(True)
        printer_manager_action_group.get_action('filter-location').set_sensitive(True)
        printer_manager_action_group.get_action('filter-manufacturer').set_sensitive(True)
        self.ui_manager = gtk.UIManager()
        self.ui_manager.insert_action_group(printer_manager_action_group, -1)
        self.ui_manager.add_ui_from_string('\n<ui>\n <accelerator action="rename-printer"/>\n <accelerator action="copy-printer"/>\n <accelerator action="delete-printer"/>\n <accelerator action="set-default-printer"/>\n <accelerator action="edit-printer"/>\n <accelerator action="create-class"/>\n <accelerator action="view-print-queue"/>\n <accelerator action="add-to-group"/>\n <accelerator action="save-as-group"/>\n <accelerator action="save-as-search-group"/>\n <accelerator action="enable-printer"/>\n <accelerator action="share-printer"/>\n <accelerator action="filter-name"/>\n <accelerator action="filter-description"/>\n <accelerator action="filter-location"/>\n <accelerator action="filter-manufacturer"/>\n</ui>\n')
        self.ui_manager.ensure_update()
        self.PrintersWindow.add_accel_group(self.ui_manager.get_accel_group())
        self.printer_context_menu = gtk.Menu()
        for action_name in [
            'edit-printer',
            'copy-printer',
            'rename-printer',
            'delete-printer',
            None,
            'enable-printer',
            'share-printer',
            'create-class',
            'set-default-printer',
            None,
            'add-to-group',
            'view-print-queue']:
            if not action_name:
                item = gtk.SeparatorMenuItem()
            else:
                action = printer_manager_action_group.get_action(action_name)
                item = action.create_menu_item()
            item.show()
            self.printer_context_menu.append(item)

        self.printer_menubar_item.set_submenu(self.printer_context_menu)
        self.jobviewers = []
        for combobox in [
            self.cmbPStartBanner,
            self.cmbPEndBanner,
            self.cmbPErrorPolicy,
            self.cmbPOperationPolicy]:
            cell = gtk.CellRendererText()
            combobox.clear()
            combobox.pack_start(cell, True)
            combobox.add_attribute(cell, 'text', 0)

        btn = self.btnRefreshMarkerLevels
        btn.connect('clicked', self.on_btnRefreshMarkerLevels_clicked)
        column = gtk.TreeViewColumn(_('Message'))
        icon = gtk.CellRendererPixbuf()
        column.pack_start(icon, False)
        text = gtk.CellRendererText()
        column.pack_start(text, False)
        column.set_cell_data_func(icon, self.set_printer_state_reason_icon)
        column.set_cell_data_func(text, self.set_printer_state_reason_text)
        column.set_resizable(True)
        self.tvPrinterStateReasons.append_column(column)
        selection = self.tvPrinterStateReasons.get_selection()
        selection.set_mode(gtk.SELECTION_NONE)
        store = gtk.ListStore(int, str)
        self.tvPrinterStateReasons.set_model(store)
        self.newPrinterGUI = np = NewPrinterGUI(self)
        np.NewPrinterWindow.set_transient_for(self.PrintersWindow)
        self.AboutDialog.set_program_name(domain)
        self.AboutDialog.set_version(config.VERSION)
        self.AboutDialog.set_icon_name('printer')

        class UnobtrusiveButton(gtk.Button):

            def __init__(self, **args):
                gtk.Button.__init__(self, **args)
                self.set_relief(gtk.RELIEF_NONE)
                label = self.get_child()
                text = label.get_text()
                label.set_use_markup(True)
                label.set_markup('<span size="small" ' + 'underline="single" ' + 'color="#0000ee">%s</span>' % text)


        problems = UnobtrusiveButton(label = _('Problems?'))
        self.hboxServerBrowse.pack_end(problems, False, False, 0)
        problems.connect('clicked', self.on_problems_button_clicked)
        problems.show()
        self.static_tabs = 3
        gtk_label_autowrap.set_autowrap(self.PrintersWindow)

        try:
            self.cups = authconn.Connection(self.PrintersWindow)
        except RuntimeError:
            self.cups = None

        self.status_context_id = self.statusbarMain.get_context_id('Connection')
        self.setConnected()
        self.setup_toolbar_for_search_entry()
        self.current_filter_text = ''
        self.current_filter_mode = 'filter-name'
        self.groups_pane = GroupsPane()
        self.current_groups_pane_item = self.groups_pane.get_selected_item()
        self.groups_pane.connect('item-activated', self.on_groups_pane_item_activated)
        self.groups_pane.connect('items-changed', self.on_groups_pane_items_changed)
        self.PrintersWindow.add_accel_group(self.groups_pane.ui_manager.get_accel_group())
        self.view_area_hpaned = gtk.HPaned()
        self.view_area_hpaned.add1(self.groups_pane)
        self.groups_pane_visible = False
        if self.groups_pane.n_groups() > 0:
            self.view_groups.set_active(True)

        self.group_menubar_item.set_submenu(self.groups_pane.groups_menu)
        self.add_to_group_menu = gtk.Menu()
        self.update_add_to_group_menu()
        action = printer_manager_action_group.get_action('add-to-group')
        for proxy in action.get_proxies():
            if isinstance(proxy, gtk.MenuItem):
                item = proxy
                break
                continue

        item.set_submenu(self.add_to_group_menu)
        menu = gtk.Menu()
        for action_name in [
            'filter-name',
            'filter-description',
            'filter-location',
            'filter-manufacturer',
            None,
            'save-as-group',
            'save-as-search-group']:
            if not action_name:
                item = gtk.SeparatorMenuItem()
            else:
                action = printer_manager_action_group.get_action(action_name)
                item = action.create_menu_item()
            menu.append(item)

        menu.show_all()
        self.search_entry.set_drop_down_menu(menu)
        self.mainlist = gtk.ListStore(gobject.TYPE_PYOBJECT, gtk.gdk.Pixbuf, gobject.TYPE_STRING, gobject.TYPE_STRING)
        self.dests_iconview.set_model(self.mainlist)
        self.dests_iconview.set_column_spacing(30)
        self.dests_iconview.set_row_spacing(20)
        self.dests_iconview.set_pixbuf_column(1)
        self.dests_iconview.set_text_column(2)
        self.dests_iconview.set_tooltip_column(3)
        self.dests_iconview.connect('key-press-event', self.dests_iconview_key_press_event)
        self.dests_iconview.connect('item-activated', self.dests_iconview_item_activated)
        self.dests_iconview.connect('selection-changed', self.dests_iconview_selection_changed)
        self.dests_iconview.connect('button-press-event', self.dests_iconview_button_press_event)
        self.dests_iconview.connect('popup-menu', self.dests_iconview_popup_menu)
        self.dests_iconview_selection_changed(self.dests_iconview)
        self.dests_iconview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, [
            ('queue', 0, 0)], gtk.gdk.ACTION_COPY)
        self.dests_iconview.connect('drag-data-get', self.dests_iconview_drag_data_get)
        m = gtk.SELECTION_MULTIPLE
        s = gtk.SELECTION_SINGLE
        for name, treeview, selection_mode in ((_('Members of this class'), self.tvClassMembers, m), (_('Others'), self.tvClassNotMembers, m), (_('Members of this class'), np.tvNCMembers, m), (_('Others'), np.tvNCNotMembers, m), (_('Devices'), np.tvNPDevices, s), (_('Connections'), np.tvNPDeviceURIs, s), (_('Makes'), np.tvNPMakes, s), (_('Models'), np.tvNPModels, s), (_('Drivers'), np.tvNPDrivers, s), (_('Downloadable Drivers'), np.tvNPDownloadableDrivers, s), (_('Users'), self.tvPUsers, m)):
            model = gtk.ListStore(str)
            cell = gtk.CellRendererText()
            column = gtk.TreeViewColumn(name, cell, text = 0)
            treeview.set_model(model)
            treeview.append_column(column)
            treeview.get_selection().set_mode(selection_mode)

        self.ServerSettingsDialog.connect('response', self.server_settings_response)
        self.PrinterPropertiesDialog.connect('response', self.printer_properties_response)
        col = gtk.TreeViewColumn('', gtk.CellRendererText(), markup = 0)
        self.tvPrinterProperties.append_column(col)
        sel = self.tvPrinterProperties.get_selection()
        sel.connect('changed', self.on_tvPrinterProperties_selection_changed)
        sel.set_mode(gtk.SELECTION_SINGLE)
        opts = [
            options.OptionAlwaysShown('copies', int, 1, self.sbJOCopies, self.btnJOResetCopies),
            options.OptionAlwaysShownSpecial('orientation-requested', int, 3, self.cmbJOOrientationRequested, self.btnJOResetOrientationRequested, combobox_map = [
                3,
                4,
                5,
                6], special_choice = _('Automatic rotation')),
            options.OptionAlwaysShown('fitplot', bool, False, self.cbJOFitplot, self.btnJOResetFitplot),
            options.OptionAlwaysShown('number-up', int, 1, self.cmbJONumberUp, self.btnJOResetNumberUp, combobox_map = [
                1,
                2,
                4,
                6,
                9,
                16]),
            options.OptionAlwaysShown('number-up-layout', str, 'lrtb', self.cmbJONumberUpLayout, self.btnJOResetNumberUpLayout, combobox_map = [
                'lrtb',
                'lrbt',
                'rltb',
                'rlbt',
                'tblr',
                'tbrl',
                'btlr',
                'btrl']),
            options.OptionAlwaysShown('brightness', int, 100, self.sbJOBrightness, self.btnJOResetBrightness),
            options.OptionAlwaysShown('finishings', int, 3, self.cmbJOFinishings, self.btnJOResetFinishings, combobox_map = [
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                20,
                21,
                22,
                23,
                24,
                25,
                26,
                27,
                28,
                29,
                30,
                31,
                50,
                51,
                52,
                53], use_supported = True),
            options.OptionAlwaysShown('job-priority', int, 50, self.sbJOJobPriority, self.btnJOResetJobPriority),
            options.OptionAlwaysShown('media', str, 'A4', self.cmbJOMedia, self.btnJOResetMedia, use_supported = True),
            options.OptionAlwaysShown('sides', str, 'one-sided', self.cmbJOSides, self.btnJOResetSides, combobox_map = [
                'one-sided',
                'two-sided-long-edge',
                'two-sided-short-edge']),
            options.OptionAlwaysShown('job-hold-until', str, 'no-hold', self.cmbJOHoldUntil, self.btnJOResetHoldUntil, use_supported = True),
            options.OptionAlwaysShown('mirror', bool, False, self.cbJOMirror, self.btnJOResetMirror),
            options.OptionAlwaysShown('scaling', int, 100, self.sbJOScaling, self.btnJOResetScaling),
            options.OptionAlwaysShown('saturation', int, 100, self.sbJOSaturation, self.btnJOResetSaturation),
            options.OptionAlwaysShown('hue', int, 0, self.sbJOHue, self.btnJOResetHue),
            options.OptionAlwaysShown('gamma', int, 1000, self.sbJOGamma, self.btnJOResetGamma),
            options.OptionAlwaysShown('cpi', float, 10, self.sbJOCpi, self.btnJOResetCpi),
            options.OptionAlwaysShown('lpi', float, 6, self.sbJOLpi, self.btnJOResetLpi),
            options.OptionAlwaysShown('page-left', int, 0, self.sbJOPageLeft, self.btnJOResetPageLeft),
            options.OptionAlwaysShown('page-right', int, 0, self.sbJOPageRight, self.btnJOResetPageRight),
            options.OptionAlwaysShown('page-top', int, 0, self.sbJOPageTop, self.btnJOResetPageTop),
            options.OptionAlwaysShown('page-bottom', int, 0, self.sbJOPageBottom, self.btnJOResetPageBottom),
            options.OptionAlwaysShown('prettyprint', bool, False, self.cbJOPrettyPrint, self.btnJOResetPrettyPrint),
            options.OptionAlwaysShown('wrap', bool, False, self.cbJOWrap, self.btnJOResetWrap),
            options.OptionAlwaysShown('columns', int, 1, self.sbJOColumns, self.btnJOResetColumns)]
        self.job_options_widgets = { }
        self.job_options_buttons = { }
        for option in opts:
            self.job_options_widgets[option.widget] = option
            self.job_options_buttons[option.button] = option

        self.monitor = monitor.Monitor(self, monitor_jobs = False)

        try:
            self.populateList()
        except cups.HTTPError:
            (s,) = None
            self.cups = None
            self.setConnected()
            self.populateList()
            show_HTTP_Error(s, self.PrintersWindow)


        try:
            (max_width, max_height) = (600, 400)
            self.dests_iconview.resize_children()
            (width, height) = self.dests_iconview.size_request()
            if height > max_height:
                self.dests_iconview.set_size_request(max_width, -1)
                self.dests_iconview.resize_children()
                while gtk.events_pending():
                    gtk.main_iteration()
                (width, height) = self.dests_iconview.size_request()
                (width, height) = map(min, (width, height), (max_width, max_height))

            self.dests_iconview.set_size_request(width, height)
            while gtk.events_pending():
                gtk.main_iteration()
            (width, height) = self.PrintersWindow.get_size()
            self.dests_iconview.set_size_request(-1, -1)
            self.PrintersWindow.resize(width, height)
        except:
            nonfatalException()

        if setup_printer:
            self.device_uri = setup_printer
            self.devid = devid
            self.ppd = None

            try:
                self.on_autodetected_printer_without_driver(None)
            except RuntimeError:
                pass
            except:
                None<EXCEPTION MATCH>RuntimeError


        None<EXCEPTION MATCH>RuntimeError
        if configure_printer:

            try:
                self.display_properties_dialog_for(configure_printer)
                if print_test_page:
                    self.btnPrintTestPage.clicked()

                if change_ppd:
                    self.btnChangePPD.clicked()
            except RuntimeError:
                pass
            except:
                None<EXCEPTION MATCH>RuntimeError


        None<EXCEPTION MATCH>RuntimeError


    def display_properties_dialog_for(self, queue):
        model = self.dests_iconview.get_model()
        iter = model.get_iter_first()
        while iter != None:
            name = unicode(model.get_value(iter, 2))
            if name == queue:
                path = model.get_path(iter)
                self.dests_iconview.scroll_to_path(path, True, 0.5, 0.5)
                self.dests_iconview.set_cursor(path)
                self.dests_iconview.item_activated(path)
                break

            iter = model.iter_next(iter)
        if iter == None:
            raise RuntimeError
        iter == None


    def setup_toolbar_for_search_entry(self):
        separator = gtk.SeparatorToolItem()
        separator.set_draw(False)
        self.toolbar.insert(separator, -1)
        self.toolbar.child_set_property(separator, 'expand', True)
        self.search_entry = ToolbarSearchEntry()
        self.search_entry.connect('search', self.on_search_entry_search)
        tool_item = gtk.ToolItem()
        tool_item.add(self.search_entry)
        self.toolbar.insert(tool_item, -1)
        self.toolbar.show_all()


    def on_search_entry_search(self, UNUSED, text):
        if not text or True:
            pass
        self.ui_manager.get_action('/save-as-group').set_sensitive(False)
        if not text or True:
            pass
        self.ui_manager.get_action('/save-as-search-group').set_sensitive(False)
        self.current_filter_text = text
        self.populateList()


    def on_groups_pane_item_activated(self, UNUSED, item):
        self.search_entry.clear()
        if isinstance(item, SavedSearchGroupItem):
            crit = item.criteria[0]
            if crit.subject == SearchCriterion.SUBJECT_NAME:
                self.ui_manager.get_action('/filter-name').activate()
            elif crit.subject == SearchCriterion.SUBJECT_DESC:
                self.ui_manager.get_action('/filter-description').activate()
            elif crit.subject == SearchCriterion.SUBJECT_LOCATION:
                self.ui_manager.get_action('/filter-location').activate()
            elif crit.subject == SearchCriterion.SUBJECT_MANUF:
                self.ui_manager.get_action('/filter-manufacturer').activate()
            else:
                nonfatalException()
            self.search_entry.set_text(crit.value)

        self.current_groups_pane_item = item
        self.populateList()


    def on_add_to_group_menu_item_activate(self, menuitem, group):
        group.add_queues(self.groups_pane.currently_selected_queues)


    def update_add_to_group_menu(self):
        for child in self.add_to_group_menu.get_children():
            self.add_to_group_menu.remove(child)

        static_groups = self.groups_pane.get_static_groups()
        for group in static_groups:
            item = gtk.MenuItem(group.name, False)
            item.connect('activate', self.on_add_to_group_menu_item_activate, group)
            self.add_to_group_menu.append(item)

        if len(static_groups) > 0:
            item = gtk.SeparatorMenuItem()
            self.add_to_group_menu.append(item)

        action = self.groups_pane.ui_manager.get_action('/new-group-from-selection')
        item = action.create_menu_item()
        self.add_to_group_menu.append(item)
        self.add_to_group_menu.show_all()


    def on_groups_pane_items_changed(self, UNUSED):
        if not self.groups_pane_visible:
            self.view_groups.set_active(True)

        self.update_add_to_group_menu()


    def on_filter_criterion_changed(self, UNUSED, selected_action):
        self.current_filter_mode = selected_action.get_name()
        self.populateList()


    def dests_iconview_item_activated(self, iconview, path):
        model = iconview.get_model()
        iter = model.get_iter(path)
        name = unicode(model.get_value(iter, 2))
        object = model.get_value(iter, 0)

        try:
            self.fillPrinterTab(name)
        except cups.IPPError:
            (e, m) = None
            show_IPP_Error(e, m, self.PrintersWindow)
            if e == cups.IPP_SERVICE_UNAVAILABLE:
                self.cups = None
                self.setConnected()
                self.populateList()

            return None
            except RuntimeError:
                return None
            else:
                self.PrinterPropertiesDialog.set_transient_for(self.PrintersWindow)
                for button in [
                    self.btnPrinterPropertiesCancel,
                    self.btnPrinterPropertiesOK,
                    self.btnPrinterPropertiesApply]:
                    if object.discovered:
                        button.hide()
                        continue
                    button.show()


        if object.discovered:
            self.btnPrinterPropertiesClose.show()
        else:
            self.btnPrinterPropertiesClose.hide()
        self.setDataButtonState()
        treeview = self.tvPrinterProperties
        treeview.set_cursor((0,))
        host = CUPS_server_hostname()
        self.PrinterPropertiesDialog.set_title(_("Printer Properties - '%s' on %s") % (name, host))
        self.PrinterPropertiesDialog.set_focus_on_map(self.focus_on_map)
        self.PrinterPropertiesDialog.show()


    def printer_properties_response(self, dialog, response):
        if response == gtk.RESPONSE_REJECT:
            message = _('There are conflicting options.\nChanges can only be applied after\nthese conflicts are resolved.')
            message += '\n\n'
            for option in self.conflicts:
                message += option.option.text + '\n'

            dialog = gtk.MessageDialog(self.PrinterPropertiesDialog, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_CLOSE, message)
            dialog.run()
            dialog.destroy()
            return None
        if response == gtk.RESPONSE_OK or response == gtk.RESPONSE_APPLY:
            success = self.save_printer(self.printer)

        if response == gtk.RESPONSE_APPLY:

            try:
                self.fillPrinterTab(self.printer.name)
            except:
                pass

            self.setDataButtonState()

        if response == gtk.RESPONSE_OK or not success or response == gtk.RESPONSE_CANCEL:
            dialog.hide()



    def dests_iconview_selection_changed(self, iconview):
        self.updating_widgets = True
        paths = iconview.get_selected_items()
        any_disabled = False
        any_enabled = False
        any_discovered = False
        any_shared = False
        any_unshared = False
        self.groups_pane.currently_selected_queues = []
        model = iconview.get_model()
        for path in paths:
            iter = model.get_iter(path)
            object = model.get_value(iter, 0)
            name = unicode(model.get_value(iter, 2))
            self.groups_pane.currently_selected_queues.append(name)
            if object.discovered:
                any_discovered = True

            if object.enabled:
                any_enabled = True
            else:
                any_disabled = True
            if object.is_shared:
                any_shared = True
                continue
            any_unshared = True

        n = len(paths)
        self.groups_pane.ui_manager.get_action('/new-group-from-selection').set_sensitive(n > 0)
        self.ui_manager.get_action('/edit-printer').set_sensitive(n == 1)
        self.ui_manager.get_action('/copy-printer').set_sensitive(n == 1)
        if n == 1:
            pass
        self.ui_manager.get_action('/rename-printer').set_sensitive(not any_discovered)
        userdef = userdefault.UserDefaultPrinter().get()
        if (n != 1 or userdef == None) and self.default_printer == name:
            set_default_sensitivity = False
        else:
            set_default_sensitivity = True
        self.ui_manager.get_action('/set-default-printer').set_sensitive(set_default_sensitivity)
        action = self.ui_manager.get_action('/enable-printer')
        if n > 0:
            pass
        action.set_sensitive(not any_discovered)
        for widget in action.get_proxies():
            if isinstance(widget, gtk.CheckMenuItem):
                if n > 1 and any_enabled:
                    pass
                widget.set_inconsistent(any_disabled)
                continue

        if not any_discovered:
            pass
        action.set_active(not any_disabled)
        action = self.ui_manager.get_action('/share-printer')
        if n > 0:
            pass
        action.set_sensitive(not any_discovered)
        for widget in action.get_proxies():
            if isinstance(widget, gtk.CheckMenuItem):
                if n > 1 and any_shared:
                    pass
                widget.set_inconsistent(any_unshared)
                continue

        if not any_discovered:
            pass
        action.set_active(not any_unshared)
        if n > 0:
            pass
        self.ui_manager.get_action('/delete-printer').set_sensitive(not any_discovered)
        self.ui_manager.get_action('/create-class').set_sensitive(n > 1)
        self.ui_manager.get_action('/add-to-group').set_sensitive(n > 0)
        self.updating_widgets = False


    def dests_iconview_popup_menu(self, iconview):
        self.printer_context_menu.popup(None, None, None, 0, 0x0L)


    def dests_iconview_button_press_event(self, iconview, event):
        if event.button > 1:
            click_path = iconview.get_path_at_pos(int(event.x), int(event.y))
            paths = iconview.get_selected_items()
            if click_path == None:
                iconview.unselect_all()
            elif click_path not in paths:
                iconview.unselect_all()
                iconview.select_path(click_path)
                cells = iconview.get_cells()
                for cell in cells:
                    if type(cell) == gtk.CellRendererText:
                        break
                        continue

                iconview.set_cursor(click_path, cell)

            self.printer_context_menu.popup(None, None, None, event.button, event.time)

        return False


    def dests_iconview_key_press_event(self, iconview, event):
        modifiers = gtk.accelerator_get_default_mod_mask()
        if (event.keyval == gtk.keysyms.BackSpace and event.keyval == gtk.keysyms.Delete or event.keyval == gtk.keysyms.KP_Delete) and event.state & modifiers == 0:
            self.ui_manager.get_action('/delete-printer').activate()
            return True
        if event.keyval == gtk.keysyms.F2 and event.state & modifiers == 0:
            self.ui_manager.get_action('/rename-printer').activate()
            return True
        return False


    def dests_iconview_drag_data_get(self, iconview, context, selection_data, info, timestamp):
        if info == 0:
            model = iconview.get_model()
            paths = iconview.get_selected_items()
            selected_printer_names = ''
            for path in paths:
                selected_printer_names += model.get_value(model.get_iter(path), 2) + '\n'

            if len(selected_printer_names) > 0:
                selection_data.set('queue', 8, selected_printer_names)

        else:
            nonfatalException()


    def on_server_settings_activate(self, menuitem):

        try:
            self.fillServerTab()
        except cups.IPPError:
            return None

        self.ServerSettingsDialog.set_transient_for(self.PrintersWindow)
        self.ServerSettingsDialog.show()


    def server_settings_response(self, dialog, response):
        if response == gtk.RESPONSE_OK:
            if not self.save_serversettings():
                dialog.hide()

        elif response == gtk.RESPONSE_YES:

            try:
                AdvancedServerSettingsDialog(self.cups, dialog, self.on_adv_server_settings_apply)
            return None

        else:
            dialog.hide()


    def on_adv_server_settings_apply(self):

        try:
            self.fillServerTab()
        except cups.IPPError:
            dialog.hide()



    def busy(self, win = None):

        try:
            if not win:
                win = self.PrintersWindow

            gdkwin = win.window
            if gdkwin:
                gdkwin.set_cursor(busy_cursor)
                while gtk.events_pending():
                    gtk.main_iteration()
        except:
            nonfatalException()



    def ready(self, win = None):

        try:
            if not win:
                win = self.PrintersWindow

            gdkwin = win.window
            if gdkwin:
                gdkwin.set_cursor(ready_cursor)
                while gtk.events_pending():
                    gtk.main_iteration()
        except:
            nonfatalException()



    def setConnected(self):
        connected = bool(self.cups)
        host = CUPS_server_hostname()
        self.PrintersWindow.set_title(_('Printer configuration - %s') % host)
        self.PrintersWindow.set_focus_on_map(self.focus_on_map)
        if connected:
            status_msg = _('Connected to %s') % host
        else:
            status_msg = _('Not connected')
        self.statusbarMain.push(self.status_context_id, status_msg)
        for widget in (self.btnNew, self.new_printer, self.new_class, self.chkServerBrowse, self.chkServerShare, self.chkServerRemoteAdmin, self.chkServerAllowCancelAll, self.chkServerLogDebug, self.server_settings_menu_entry):
            widget.set_sensitive(connected)

        sharing = self.chkServerShare.get_active()
        self.chkServerShareAny.set_sensitive(sharing)

        try:
            del self.server_settings
        except:
            pass



    def getServers(self):
        self.servers.discard(None)
        known_servers = list(self.servers)
        known_servers.sort()
        return known_servers


    def populateList(self, prompt_allowed = True):
        selected_printers = set()
        paths = self.dests_iconview.get_selected_items()
        model = self.dests_iconview.get_model()
        for path in paths:
            iter = model.get_iter(path)
            name = unicode(model.get_value(iter, 2))
            selected_printers.add(name)

        if self.cups:
            self.cups._set_prompt_allowed(prompt_allowed)
            self.cups._begin_operation(_('obtaining queue details'))

            try:
                self.printers = cupshelpers.getPrinters(self.cups)
                self.default_printer = self.cups.getDefault()
            except cups.IPPError:
                (e, m) = None
                show_IPP_Error(e, m, self.PrintersWindow)
                self.printers = { }
                self.default_printer = None

            self.cups._end_operation()
            self.cups._set_prompt_allowed(True)
        else:
            self.printers = { }
            self.default_printer = None
        for name, printer in self.printers.iteritems():
            self.servers.add(printer.getServer())

        userdef = userdefault.UserDefaultPrinter().get()
        local_printers = []
        local_classes = []
        remote_printers = []
        remote_classes = []
        if isinstance(self.current_groups_pane_item, AllPrintersItem) or isinstance(self.current_groups_pane_item, SavedSearchGroupItem):
            delete_action = self.ui_manager.get_action('/delete-printer')
            delete_action.set_properties(label = None)
            printers_set = self.printers
        elif isinstance(self.current_groups_pane_item, FavouritesItem):
            printers_set = { }
        elif isinstance(self.current_groups_pane_item, StaticGroupItem):
            delete_action = self.ui_manager.get_action('/delete-printer')
            delete_action.set_properties(label = _('Remove from Group'))
            printers_set = { }
            deleted_printers = []
            for printer_name in self.current_groups_pane_item.printer_queues:

                try:
                    printer = self.printers[printer_name]
                    printers_set[printer_name] = printer
                continue
                except KeyError:
                    deleted_printers.append(printer_name)
                    continue



            self.current_groups_pane_item.remove_queues(deleted_printers)
        else:
            printers_set = self.printers
            nonfatalException()
        if len(self.current_filter_text) > 0:
            printers_subset = { }
            pattern = re.compile(self.current_filter_text, re.I)
            if self.current_filter_mode == 'filter-name':
                for name in printers_set.keys():
                    if pattern.search(name) != None:
                        printers_subset[name] = printers_set[name]
                        continue

            elif self.current_filter_mode == 'filter-description':
                for name, printer in printers_set.iteritems():
                    if pattern.search(printer.info) != None:
                        printers_subset[name] = printers_set[name]
                        continue

            elif self.current_filter_mode == 'filter-location':
                for name, printer in printers_set.iteritems():
                    if pattern.search(printer.location) != None:
                        printers_subset[name] = printers_set[name]
                        continue

            elif self.current_filter_mode == 'filter-manufacturer':
                for name, printer in printers_set.iteritems():
                    if pattern.search(printer.make_and_model) != None:
                        printers_subset[name] = printers_set[name]
                        continue

            else:
                nonfatalException()
            printers_set = printers_subset

        if not self.view_discovered_printers.get_active():
            printers_subset = { }
            for name, printer in printers_set.iteritems():
                if not printer.discovered:
                    printers_subset[name] = printer
                    continue

            printers_set = printers_subset

        for name, printer in printers_set.iteritems():
            if printer.remote:
                if printer.is_class:
                    remote_classes.append(name)
                else:
                    remote_printers.append(name)
            printer.is_class
            if printer.is_class:
                local_classes.append(name)
                continue
            local_printers.append(name)

        local_printers.sort()
        local_classes.sort()
        remote_printers.sort()
        remote_classes.sort()
        self.mainlist.clear()
        PRINTER_TYPE = {
            'discovered-printer': (_('Network printer (discovered)'), 'i-network-printer'),
            'discovered-class': (_('Network class (discovered)'), 'i-network-printer'),
            'local-printer': (_('Printer'), 'gnome-dev-printer'),
            'local-fax': (_('Fax'), 'gnome-dev-printer'),
            'local-class': (_('Class'), 'gnome-dev-printer'),
            'ipp-printer': (_('Network printer'), 'i-network-printer'),
            'smb-printer': (_('Network print share'), 'gnome-dev-printer'),
            'network-printer': (_('Network printer'), 'i-network-printer') }
        theme = gtk.icon_theme_get_default()
        for printers in (local_printers, local_classes, remote_printers, remote_classes):
            if not printers:
                continue

            for name in printers:
                type = 'local-printer'
                object = printers_set[name]
                if object.discovered:
                    if object.is_class:
                        type = 'discovered-class'
                    else:
                        type = 'discovered-printer'
                elif object.is_class:
                    type = 'local-class'
                else:
                    (scheme, rest) = urllib.splittype(object.device_uri)
                    if scheme == 'ipp':
                        type = 'ipp-printer'
                    elif scheme == 'smb':
                        type = 'smb-printer'
                    elif scheme == 'hpfax':
                        type = 'local-fax'
                    elif scheme in ('socket', 'lpd'):
                        type = 'network-printer'

                (tip, icon) = PRINTER_TYPE[type]
                (w, h) = gtk.icon_size_lookup(gtk.ICON_SIZE_DIALOG)

                try:
                    pixbuf = theme.load_icon(icon, w, 0)
                except gobject.GError:
                    pixbuf = None
                    for p in [
                        iconpath,
                        'icons/']:

                        try:
                            pixbuf = gtk.gdk.pixbuf_new_from_file('%s%s.png' % (p, icon))
                        continue
                        except gobject.GError:
                            continue



                    if pixbuf == None:

                        try:
                            pixbuf = theme.load_icon('printer', w, 0)
                        pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, w, h)
                        pixbuf.fill(0)


                except:
                    None<EXCEPTION MATCH>gobject.GError

                emblem = None
                if name == self.default_printer:
                    emblem = 'emblem-default'
                elif name == userdef:
                    emblem = 'emblem-favorite'

                if emblem:
                    (w, h) = gtk.icon_size_lookup(gtk.ICON_SIZE_DIALOG)
                    default_emblem = theme.load_icon(emblem, w / 2, 0)
                    copy = pixbuf.copy()
                    default_emblem.composite(copy, 0, 0, copy.get_width(), copy.get_height(), 0, 0, 1, 1, gtk.gdk.INTERP_NEAREST, 255)
                    pixbuf = copy

                self.mainlist.append(row = [
                    object,
                    pixbuf,
                    name,
                    tip])


        model = self.dests_iconview.get_model()

        def maybe_select(model, path, iter):
            name = unicode(model.get_value(iter, 2))
            if name in selected_printers:
                self.dests_iconview.select_path(path)


        model.foreach(maybe_select)
        if self.printer != None and self.printer.name not in self.printers.keys():
            self.PrinterPropertiesDialog.response(gtk.RESPONSE_CANCEL)



    def on_connect_servername_changed(self, widget):
        self.btnConnect.set_sensitive(len(widget.get_active_text()) > 0)


    def on_connect_activate(self, widget):
        servers = self.getServers()
        if not self.printer or self.printer.getServer():
            pass
        current_server = cups.getServer()
        store = gtk.ListStore(gobject.TYPE_STRING)
        self.cmbServername.set_model(store)
        for server in servers:
            self.cmbServername.append_text(server)

        self.cmbServername.show()
        self.cmbServername.child.set_text(current_server)
        self.chkEncrypted.set_active(cups.getEncryption() == cups.HTTP_ENCRYPT_ALWAYS)
        self.cmbServername.child.set_activates_default(True)
        self.cmbServername.grab_focus()
        self.ConnectDialog.set_transient_for(self.PrintersWindow)
        response = self.ConnectDialog.run()
        self.ConnectDialog.hide()
        if response != gtk.RESPONSE_OK:
            return None
        if self.chkEncrypted.get_active():
            cups.setEncryption(cups.HTTP_ENCRYPT_ALWAYS)
        else:
            cups.setEncryption(cups.HTTP_ENCRYPT_IF_REQUESTED)
        self.connect_encrypt = cups.getEncryption()
        servername = self.cmbServername.child.get_text()
        self.lblConnecting.set_markup(_('<i>Opening connection to %s</i>') % servername)
        self.newPrinterGUI.dropPPDs()
        self.ConnectingDialog.set_transient_for(self.PrintersWindow)
        self.ConnectingDialog.show()
        gobject.timeout_add(40, self.update_connecting_pbar)
        self.connect_server = servername
        cups.setServer(self.connect_server)
        cups.setUser('')
        self.connect_user = cups.getUser()
        self.connect_thread = thread.start_new_thread(self.connect, (self.PrintersWindow,))


    def update_connecting_pbar(self):
        if not self.ConnectingDialog.get_property('visible'):
            return False
        self.pbarConnecting.pulse()
        return True


    def on_connectingdialog_delete(self, widget, event):
        self.on_cancel_connect_clicked(widget)
        return True


    def on_cancel_connect_clicked(self, widget):
        """
        Stop connection to new server
        (Doesn't really stop but sets flag for the connecting thread to
        ignore the connection)
        """
        self.connect_thread = None
        self.ConnectingDialog.hide()


    def connect(self, parent = None):
        '''
        Open a connection to a new server. Is executed in a separate thread!
        '''
        cups.setUser(self.connect_user)
        if self.connect_server[0] == '/':

            try:
                connection = cups.Connection(host = self.connect_server, encryption = self.connect_encrypt)
                del connection
            except RuntimeError:
                cups.setServer('localhost')
            except:
                None<EXCEPTION MATCH>RuntimeError
                nonfatalException()


        None<EXCEPTION MATCH>RuntimeError

        try:
            connection = authconn.Connection(parent, host = self.connect_server, encryption = self.connect_encrypt)
            self.newPrinterGUI.dropPPDs()
        except RuntimeError:
            s = None
            if self.connect_thread != thread.get_ident():
                return None
            gtk.gdk.threads_enter()
            self.ConnectingDialog.hide()
            show_IPP_Error(None, s, parent)
            gtk.gdk.threads_leave()
            return None
            self.connect_thread != thread.get_ident()
            except cups.IPPError:
                (e, s) = None
                if self.connect_thread != thread.get_ident():
                    return None
                gtk.gdk.threads_enter()
                self.ConnectingDialog.hide()
                show_IPP_Error(e, s, parent)
                gtk.gdk.threads_leave()
                return None
                self.connect_thread != thread.get_ident()
                nonfatalException()


        if self.connect_thread != thread.get_ident():
            return None
        gtk.gdk.threads_enter()

        try:
            self.ConnectingDialog.hide()
            self.cups = connection
            self.setConnected()
            self.populateList()
        except cups.HTTPError:
            self.connect_thread != thread.get_ident()
            (s,) = self.connect_thread != thread.get_ident()
            None<EXCEPTION MATCH>cups.IPPError
            self.cups = None
            self.setConnected()
            self.populateList()
            show_HTTP_Error(s, parent)
        except:
            self.connect_thread != thread.get_ident()
            None<EXCEPTION MATCH>cups.IPPError
            nonfatalException()

        gtk.gdk.threads_leave()


    def reconnect(self):
        '''Reconnect to CUPS after the server has reloaded.'''
        attempt = 1
        while attempt <= 5:

            try:
                time.sleep(1)
                self.cups._connect()
            continue
            except RuntimeError:
                attempt += 1
                continue


            None<EXCEPTION MATCH>RuntimeError


    def on_btnCancelConnect_clicked(self, widget):
        '''Close Connect dialog'''
        self.ConnectWindow.hide()


    def on_btnRefresh_clicked(self, button):
        if self.cups == None:

            try:
                self.cups = authconn.Connection(self.PrintersWindow)
            except RuntimeError:
                pass

            self.setConnected()

        self.populateList()


    def on_printer_changed(self, widget):
        if isinstance(widget, gtk.CheckButton):
            value = widget.get_active()
        elif isinstance(widget, gtk.Entry):
            value = widget.get_text()
        elif isinstance(widget, gtk.RadioButton):
            value = widget.get_active()
        elif isinstance(widget, gtk.ComboBox):
            model = widget.get_model()
            iter = widget.get_active_iter()
            value = model.get_value(iter, 1)
        else:
            raise ValueError, 'Widget type not supported (yet)'
        p = isinstance(widget, gtk.CheckButton).printer
        old_values = {
            self.entPDescription: p.info,
            self.entPLocation: p.location,
            self.entPDevice: p.device_uri,
            self.chkPEnabled: p.enabled,
            self.chkPAccepting: not (p.rejecting),
            self.chkPShared: p.is_shared,
            self.cmbPStartBanner: p.job_sheet_start,
            self.cmbPEndBanner: p.job_sheet_end,
            self.cmbPErrorPolicy: p.error_policy,
            self.cmbPOperationPolicy: p.op_policy,
            self.rbtnPAllow: p.default_allow }
        old_value = old_values[widget]
        if old_value == value:
            self.changed.discard(widget)
        else:
            self.changed.add(widget)
        self.setDataButtonState()


    def option_changed(self, option):
        if option.is_changed():
            self.changed.add(option)
        else:
            self.changed.discard(option)
        if option.conflicts:
            self.conflicts.add(option)
        else:
            self.conflicts.discard(option)
        self.setDataButtonState()
        if self.option_manualfeed and self.option_inputslot and option == self.option_manualfeed:
            if option.get_current_value() == 'True':
                self.option_inputslot.disable()
            else:
                self.option_inputslot.enable()



    def getPUsers(self):
        '''return list of usernames from the GUI'''
        model = self.tvPUsers.get_model()
        result = []
        (model.foreach,)((lambda model, path, iter: result.append(model.get(iter, 0)[0])))
        result.sort()
        return result


    def setPUsers(self, users):
        '''write list of usernames inot the GUI'''
        model = self.tvPUsers.get_model()
        model.clear()
        for user in users:
            model.append((user,))

        self.on_entPUser_changed(self.entPUser)
        self.on_tvPUsers_cursor_changed(self.tvPUsers)


    def checkPUsersChanged(self):
        '''check if users in GUI and printer are different
        and set self.changed'''
        if self.getPUsers() != self.printer.except_users:
            self.changed.add(self.tvPUsers)
        else:
            self.changed.discard(self.tvPUsers)
        self.on_tvPUsers_cursor_changed(self.tvPUsers)
        self.setDataButtonState()


    def on_btnPAddUser_clicked(self, button):
        user = self.entPUser.get_text()
        if user:
            self.tvPUsers.get_model().insert(0, (user,))
            self.entPUser.set_text('')

        self.checkPUsersChanged()


    def on_btnPDelUser_clicked(self, button):
        (model, rows) = self.tvPUsers.get_selection().get_selected_rows()
        rows = [ gtk.TreeRowReference(model, row) for row in rows ]
        for row in rows:
            path = row.get_path()
            iter = model.get_iter(path)
            model.remove(iter)

        self.checkPUsersChanged()


    def on_entPUser_changed(self, widget):
        self.btnPAddUser.set_sensitive(bool(widget.get_text()))


    def on_tvPUsers_cursor_changed(self, widget):
        (model, rows) = widget.get_selection().get_selected_rows()
        self.btnPDelUser.set_sensitive(bool(rows))


    def on_job_option_reset(self, button):
        option = self.job_options_buttons[button]
        option.reset()
        if self.server_side_options.has_key(option.name):
            del self.server_side_options[option.name]

        if option.is_changed():
            self.changed.add(option)
        else:
            self.changed.discard(option)
        self.setDataButtonState()


    def on_job_option_changed(self, widget):
        if not self.printer:
            return None
        option = self.job_options_widgets[widget]
        option.changed()
        if option.is_changed():
            self.server_side_options[option.name] = option
            self.changed.add(option)
        elif self.server_side_options.has_key(option.name):
            del self.server_side_options[option.name]

        self.changed.discard(option)
        self.setDataButtonState()


    def draw_other_job_options(self, editable = True):
        n = len(self.other_job_options)
        if n == 0:
            self.tblJOOther.hide_all()
            return None
        self.tblJOOther.resize(n, 3)
        children = self.tblJOOther.get_children()
        for child in children:
            self.tblJOOther.remove(child)

        i = 0
        for opt in self.other_job_options:
            self.tblJOOther.attach(opt.label, 0, 1, i, i + 1, xoptions = gtk.FILL, yoptions = gtk.FILL)
            opt.label.set_alignment(0, 0.5)
            self.tblJOOther.attach(opt.selector, 1, 2, i, i + 1, xoptions = gtk.FILL, yoptions = 0)
            opt.selector.set_sensitive(editable)
            btn = gtk.Button(stock = 'gtk-remove')
            btn.connect('clicked', self.on_btnJOOtherRemove_clicked)
            btn.set_data('pyobject', opt)
            btn.set_sensitive(editable)
            self.tblJOOther.attach(btn, 2, 3, i, i + 1, xoptions = 0, yoptions = 0)
            i += 1

        self.tblJOOther.show_all()


    def add_job_option(self, name, value = '', supported = '', is_new = True, editable = True):
        option = options.OptionWidget(name, value, supported, self.option_changed)
        option.is_new = is_new
        self.other_job_options.append(option)
        self.draw_other_job_options(editable = editable)
        self.server_side_options[name] = option
        if name in self.changed:
            option.is_new = False

        self.changed.add(option)
        self.setDataButtonState()
        if is_new:
            option.selector.grab_focus()



    def on_btnJOOtherRemove_clicked(self, button):
        option = button.get_data('pyobject')
        self.other_job_options.remove(option)
        self.draw_other_job_options()
        if option.is_new:
            self.changed.discard(option)
        else:
            self.changed.add(option.name)
        del self.server_side_options[option.name]
        self.setDataButtonState()


    def on_btnNewJobOption_clicked(self, button):
        name = self.entNewJobOption.get_text()
        self.add_job_option(name)
        self.tblJOOther.show_all()
        self.entNewJobOption.set_text('')
        self.btnNewJobOption.set_sensitive(False)
        self.setDataButtonState()


    def on_entNewJobOption_changed(self, widget):
        text = self.entNewJobOption.get_text()
        if len(text) > 0:
            pass
        active = text not in self.server_side_options
        self.btnNewJobOption.set_sensitive(active)


    def on_entNewJobOption_activate(self, widget):
        self.on_btnNewJobOption_clicked(widget)


    def setDataButtonState(self):

        try:
            if self.ppd and not bool(self.changed) and self.printer.enabled:
                pass
            possible = not (self.printer.rejecting)
            self.btnPrintTestPage.set_sensitive(possible)
            commands = self.printer.type & cups.CUPS_PRINTER_COMMANDS != 0
            if commands:
                pass
            self.btnSelfTest.set_sensitive(possible)
            if commands:
                pass
            self.btnCleanHeads.set_sensitive(possible)
        except:
            pass

        installablebold = False
        optionsbold = False
        if self.conflicts:
            debugprint('Conflicts detected')
            self.btnConflict.show()
            for option in self.conflicts:
                if option.tab_label == self.lblPInstallOptions:
                    installablebold = True
                    continue
                optionsbold = True

        else:
            self.btnConflict.hide()
        installabletext = _('Installable Options')
        optionstext = _('Printer Options')
        if installablebold:
            installabletext = '<b>%s</b>' % installabletext

        if optionsbold:
            optionstext = '<b>%s</b>' % optionstext

        self.lblPInstallOptions.set_markup(installabletext)
        self.lblPOptions.set_markup(optionstext)
        store = self.tvPrinterProperties.get_model()
        if store:
            for n in range(self.ntbkPrinter.get_n_pages()):
                page = self.ntbkPrinter.get_nth_page(n)
                label = self.ntbkPrinter.get_tab_label(page)

                try:
                    if label == self.lblPInstallOptions:
                        iter = store.get_iter((n,))
                        store.set_value(iter, 0, installabletext)
                    elif label == self.lblPOptions:
                        iter = store.get_iter((n,))
                        store.set_value(iter, 0, optionstext)
                continue
                except ValueError:
                    continue




        if len(self.changed) > 0:
            pass
        self.btnPrinterPropertiesApply.set_sensitive(not (self.conflicts))
        self.btnPrinterPropertiesOK.set_sensitive(not (self.conflicts))


    def save_printer(self, printer, saveall = False, parent = None):
        if parent == None:
            parent = self.PrinterPropertiesDialog

        class_deleted = False
        name = printer.name
        if printer.is_class:
            self.cups._begin_operation(_('modifying class %s') % name)
        else:
            self.cups._begin_operation(_('modifying printer %s') % name)

        try:
            if not (printer.is_class) and self.ppd:
                self.getPrinterSettings()
                if self.ppd.nondefaultsMarked() or saveall:
                    self.cups.addPrinter(name, ppd = self.ppd)


            if printer.is_class:
                new_members = getCurrentClassMembers(self.tvClassMembers)
                if not new_members:
                    dialog = gtk.MessageDialog(flags = 0, type = gtk.MESSAGE_WARNING, buttons = gtk.BUTTONS_YES_NO, message_format = _('This will delete this class!'))
                    dialog.format_secondary_text(_('Proceed anyway?'))
                    result = dialog.run()
                    dialog.destroy()
                    if result == gtk.RESPONSE_NO:
                        self.cups._end_operation()
                        return True
                    class_deleted = True

                old_members = printer.class_members[:]
                for member in new_members:
                    if member in old_members:
                        old_members.remove(member)
                        continue
                    self.cups.addPrinterToClass(member, name)

                for member in old_members:
                    self.cups.deletePrinterFromClass(member, name)


            location = self.entPLocation.get_text()
            info = self.entPDescription.get_text()
            device_uri = self.entPDevice.get_text()
            enabled = self.chkPEnabled.get_active()
            accepting = self.chkPAccepting.get_active()
            shared = self.chkPShared.get_active()
            if info != printer.info or saveall:
                self.cups.setPrinterInfo(name, info)

            if location != printer.location or saveall:
                self.cups.setPrinterLocation(name, location)

            if not (printer.is_class):
                if device_uri != printer.device_uri or saveall:
                    self.cups.setPrinterDevice(name, device_uri)

            if enabled != printer.enabled or saveall:
                self.printer.setEnabled(enabled)

            if accepting == printer.rejecting or saveall:
                self.printer.setAccepting(accepting)

            if shared != printer.is_shared or saveall:
                self.printer.setShared(shared)


            def get_combo_value(cmb):
                model = cmb.get_model()
                iter = cmb.get_active_iter()
                return model.get_value(iter, 1)

            job_sheet_start = get_combo_value(self.cmbPStartBanner)
            job_sheet_end = get_combo_value(self.cmbPEndBanner)
            error_policy = get_combo_value(self.cmbPErrorPolicy)
            op_policy = get_combo_value(self.cmbPOperationPolicy)
            if job_sheet_start != printer.job_sheet_start or job_sheet_end != printer.job_sheet_end or saveall:
                printer.setJobSheets(job_sheet_start, job_sheet_end)

            if error_policy != printer.error_policy or saveall:
                printer.setErrorPolicy(error_policy)

            if op_policy != printer.op_policy or saveall:
                printer.setOperationPolicy(op_policy)

            default_allow = self.rbtnPAllow.get_active()
            except_users = self.getPUsers()
            if default_allow != printer.default_allow or except_users != printer.except_users or saveall:
                printer.setAccess(default_allow, except_users)

            for option in printer.attributes:
                if option not in self.server_side_options:
                    printer.unsetOption(option)
                    continue

            for option in self.server_side_options.itervalues():
                if (option.is_changed() or saveall) and option.get_current_value() != option.system_default:
                    printer.setOption(option.name, option.get_current_value())
                    continue
        except cups.IPPError:
            (e, s) = None
            show_IPP_Error(e, s, parent)
            self.cups._end_operation()
            return True

        self.cups._end_operation()
        self.changed = set()
        if not (self.cups._use_pk) and not self.__dict__.has_key('server_settings'):
            self.cups._begin_operation(_('fetching server settings'))

            try:
                self.server_settings = self.cups.adminGetServerSettings()
            except:
                nonfatalException()

            self.cups._end_operation()

        if class_deleted:
            self.monitor.update()
        else:
            self.cups._begin_operation(_('obtaining queue details'))

            try:
                printers = cupshelpers.getPrinters(self.cups)
                this_printer = {
                    name: printers[name] }
                self.printers.update(this_printer)
            except cups.IPPError:
                (e, s) = None
                show_IPP_Error(e, s, self.PrinterPropertiesDialog)
            except KeyError:
                self.populateList()

            self.cups._end_operation()
        return False


    def getPrinterSettings(self):
        for option in self.options.itervalues():
            option.writeback()



    def on_tvPrinterProperties_selection_changed(self, selection):
        (model, iter) = selection.get_selected()
        if iter:
            self.printer_properties_last_iter_selected = iter
        else:

            try:
                iter = self.printer_properties_last_iter_selected
            except AttributeError:
                return None

            if model.iter_is_valid(iter):
                selection.select_iter(iter)



    def on_tvPrinterProperties_cursor_changed(self, treeview):
        (path, column) = treeview.get_cursor()
        if path != None:
            model = treeview.get_model()
            iter = model.get_iter(path)
            n = model.get_value(iter, 1)
            self.ntbkPrinter.set_current_page(n)



    def set_system_or_user_default_printer(self, name):
        userdef = userdefault.UserDefaultPrinter()
        if name == self.default_printer:
            userdef.clear()
            self.populateList()
            return None
        userdefault.UserDefaultPrompt(self.set_default_printer, self.populateList, name, _('Set Default Printer'), self.PrintersWindow, _('Do you want to set this as the system-wide default printer?'), _('Set as the _system-wide default printer'), _('_Clear my personal default setting'), _('Set as my _personal default printer'))


    def set_default_printer(self, name):
        printer = self.printers[name]
        reload = False
        self.cups._begin_operation(_('setting default printer'))

        try:
            reload = printer.setAsDefault()
        except cups.HTTPError:
            (s,) = None
            show_HTTP_Error(s, self.PrintersWindow)
            self.cups._end_operation()
            return None
            except cups.IPPError:
                (e, msg) = None
                show_IPP_Error(e, msg, self.PrintersWindow)
                self.cups._end_operation()
                return None
            else:
                self.cups._end_operation()
                if reload:
                    self.reconnect()



        try:
            self.populateList()
        except cups.HTTPError:
            (s,) = None
            self.cups = None
            self.setConnected()
            self.populateList()
            show_HTTP_Error(s, self.PrintersWindow)



    def on_btnPrintTestPage_clicked(self, button):
        if self.ppd == False:
            return None
        custom_testpage = None
        if self.ppd != False:
            opt = self.ppd.findOption('PageSize')
            if opt:
                custom_testpage = os.path.join(pkgdata, 'testpage-%s.ps' % opt.defchoice.lower())


        user = cups.getUser()
        cups.setUser('')

        try:
            c = authconn.Connection(self.PrintersWindow, try_as_root = False, host = self.connect_server, encryption = self.connect_encrypt)
        except RuntimeError:
            s = None
            show_IPP_Error(None, s, self.PrintersWindow)
            return None

        job_id = None
        c._begin_operation(_('printing test page'))

        try:
            if custom_testpage and os.path.exists(custom_testpage):
                debugprint('Printing custom test page ' + custom_testpage)
                job_id = c.printTestPage(self.printer.name, file = custom_testpage)
            else:
                debugprint('Printing default test page')
                job_id = c.printTestPage(self.printer.name)
        except cups.IPPError:
            (e, msg) = None
            if e == cups.IPP_NOT_AUTHORIZED and self.connect_server != 'localhost' and self.connect_server[0] != '/':
                show_error_dialog(_('Not possible'), _('The remote server did not accept the print job, most likely because the printer is not shared.'), self.PrintersWindow)
            else:
                show_IPP_Error(e, msg, self.PrintersWindow)
        except:
            self.connect_server[0] != '/'

        c._end_operation()
        cups.setUser(user)
        if job_id != None:
            show_info_dialog(_('Submitted'), _('Test page submitted as job %d') % job_id, parent = self.PrintersWindow)



    def maintenance_command(self, command):
        (tmpfd, tmpfname) = tempfile.mkstemp()
        os.write(tmpfd, '#CUPS-COMMAND\n%s\n' % command)
        os.close(tmpfd)
        self.cups._begin_operation(_('sending maintenance command'))

        try:
            format = 'application/vnd.cups-command'
            job_id = self.cups.printTestPage(self.printer.name, format = format, file = tmpfname, user = self.connect_user)
            show_info_dialog(_('Submitted'), _('Maintenance command submitted as job %d') % job_id, parent = self.PrintersWindow)
        except cups.IPPError:
            (e, msg) = None
            if e == cups.IPP_NOT_AUTHORIZED and self.printer.name != 'localhost':
                show_error_dialog(_('Not possible'), _('The remote server did not accept the print job, most likely because the printer is not shared.'), self.PrintersWindow)
            else:
                show_IPP_Error(e, msg, self.PrintersWindow)
        except:
            self.printer.name != 'localhost'

        self.cups._end_operation()
        os.unlink(tmpfname)


    def on_btnSelfTest_clicked(self, button):
        self.maintenance_command('PrintSelfTestPage')


    def on_btnCleanHeads_clicked(self, button):
        self.maintenance_command('Clean all')


    def fillComboBox(self, combobox, values, value, translationdict = None):
        if translationdict == None:
            translationdict = ppdippstr.TranslactionDict()

        model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
        combobox.set_model(model)
        set_active = False
        for nr, val in enumerate(values):
            model.append([
                translationdict.get(val),
                val])
            if val == value:
                combobox.set_active(nr)
                set_active = True
                continue

        if not set_active:
            combobox.set_active(0)



    def fillPrinterTab(self, name):
        self.changed = set()
        self.options = { }
        self.conflicts = set()
        printer = self.printers[name]
        self.printer = printer
        printer.getAttributes()

        try:
            publishing = printer.other_attributes['server-is-sharing-printers']
            self.server_is_publishing = publishing
        except KeyError:
            pass

        editable = not (self.printer.discovered)
        editablePPD = not (self.printer.remote)

        try:
            self.ppd = printer.getPPD()
            self.ppd_local = printer.getPPD()
            if self.ppd_local != False:
                self.ppd_local.localize()
        except cups.IPPError:
            (e, m) = None
            show_IPP_Error(e, m, self.PrintersWindow)
            self.ppd = False
        except RuntimeError:
            show_error_dialog(_('Error'), _('There was a problem connecting to the CUPS server.'), self.PrintersWindow)
            raise

        for widget in (self.entPDescription, self.entPLocation, self.entPDevice):
            widget.set_editable(editable)

        for widget in (self.btnSelectDevice, self.btnChangePPD, self.chkPEnabled, self.chkPAccepting, self.chkPShared, self.cmbPStartBanner, self.cmbPEndBanner, self.cmbPErrorPolicy, self.cmbPOperationPolicy, self.rbtnPAllow, self.rbtnPDeny, self.tvPUsers, self.entPUser, self.btnPAddUser, self.btnPDelUser):
            widget.set_sensitive(editable)

        self.entPDescription.set_text(printer.info)
        self.entPLocation.set_text(printer.location)
        uri = printer.device_uri
        self.entPDevice.set_text(uri)
        self.changed.discard(self.entPDevice)
        for widget in (self.lblPMakeModel2, self.lblPMakeModel, self.btnChangePPD, self.lblPDevice2, self.entPDevice, self.btnSelectDevice):
            if printer.is_class:
                widget.hide()
                continue
            widget.show()


        try:
            if printer.is_shared:
                if self.server_is_publishing:
                    self.lblNotPublished.hide_all()
                else:
                    self.lblNotPublished.show_all()
            else:
                self.lblNotPublished.hide_all()
        except:
            nonfatalException()
            self.lblNotPublished.hide_all()

        self.cmbPStartBanner.set_sensitive(editable)
        self.cmbPEndBanner.set_sensitive(editable)
        self.cmbPErrorPolicy.set_sensitive(editable)
        self.cmbPOperationPolicy.set_sensitive(editable)
        self.entPUser.set_text('')
        self.server_side_options = { }
        for option in self.job_options_widgets.values():
            if option.name == 'media' and self.ppd:
                opt = self.ppd.findOption('PageSize')
                if opt:
                    option.set_default(opt.defchoice)


            option_editable = editable

            try:
                value = self.printer.attributes[option.name]
            except KeyError:
                option.reinit(None)


            try:
                if self.printer.possible_attributes.has_key(option.name):
                    supported = self.printer.possible_attributes[option.name][1]
                    option.reinit(value, supported = supported)
                else:
                    option.reinit(value)
                self.server_side_options[option.name] = option
            except:
                option_editable = False
                show_error_dialog(_('Error'), _("Option '%s' has value '%s' and cannot be edited.") % (option.name, value), self.PrintersWindow)

            option.widget.set_sensitive(option_editable)
            if not editable:
                option.button.set_sensitive(False)
                continue

        self.other_job_options = []
        self.draw_other_job_options(editable = editable)
        for option in self.printer.attributes.keys():
            if self.server_side_options.has_key(option):
                continue

            value = self.printer.attributes[option]
            if self.printer.possible_attributes.has_key(option):
                supported = self.printer.possible_attributes[option][1]
            elif isinstance(value, bool):
                supported = [
                    'true',
                    'false']
                value = str(value).lower()
            else:
                supported = ''
                value = str(value)
            self.add_job_option(option, value = value, supported = supported, is_new = False, editable = editable)

        self.entNewJobOption.set_text('')
        self.entNewJobOption.set_sensitive(editable)
        self.btnNewJobOption.set_sensitive(False)
        if printer.is_class:
            tab_nr = self.ntbkPrinter.page_num(self.swPInstallOptions)
            if tab_nr != -1:
                self.ntbkPrinter.remove_page(tab_nr)

            self.fillClassMembers(name, editable)
        else:
            self.fillPrinterOptions(name, editablePPD)
        self.updateMarkerLevels()
        self.updateStateReasons()
        self.updatePrinterPropertiesTreeView()
        self.changed = set()
        self.updatePrinterProperties()
        self.setDataButtonState()


    def updatePrinterPropertiesTreeView(self):
        store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT)
        self.ntbkPrinter.set_show_tabs(False)
        for n in range(self.ntbkPrinter.get_n_pages()):
            page = self.ntbkPrinter.get_nth_page(n)
            label = self.ntbkPrinter.get_tab_label(page)
            iter = store.append(None)
            store.set_value(iter, 0, label.get_text())
            store.set_value(iter, 1, n)

        sel = self.tvPrinterProperties.get_selection()
        self.tvPrinterProperties.set_model(store)


    def updateMarkerLevels(self):
        printer = self.printer
        for widget in self.vboxMarkerLevels.get_children():
            self.vboxMarkerLevels.remove(widget)

        marker_info = dict()
        for attr in [
            'marker-colors',
            'marker-names',
            'marker-types',
            'marker-levels']:
            marker_info[attr] = printer.other_attributes.get(attr, [])

        markers = map((lambda color, name, type, level: (color, name, type, level)), marker_info['marker-colors'], marker_info['marker-names'], marker_info['marker-types'], marker_info['marker-levels'])
        debugprint(markers)
        can_refresh = self.printer.type & cups.CUPS_PRINTER_COMMANDS != 0
        self.btnRefreshMarkerLevels.set_sensitive(can_refresh)
        if len(markers) == 0:
            label = gtk.Label(_('Marker levels are not reported for this printer.'))
            label.set_line_wrap(True)
            label.set_alignment(0, 0)
            self.vboxMarkerLevels.pack_start(label, False, False, 0)
        else:
            num_markers = 0
            cols = len(markers)
            rows = 1 + (cols - 1) / 4
            if cols > 4:
                cols = 4

            table = gtk.Table(rows = rows, columns = cols, homogeneous = True)
            table.set_col_spacings(6)
            table.set_row_spacings(12)
            self.vboxMarkerLevels.pack_start(table)
            for color, name, marker_type, level in markers:
                if name == None:
                    name = ''

                row = num_markers / 4
                col = num_markers % 4
                vbox = gtk.VBox(spacing = 6)
                subhbox = gtk.HBox()
                inklevel = gtkinklevel.GtkInkLevel(color, level)
                subhbox.pack_start(inklevel, True, False, 0)
                vbox.pack_start(subhbox, False, False, 0)
                label = gtk.Label(name)
                label.set_line_wrap(True)
                vbox.pack_start(label, False, False, 0)
                table.attach(vbox, col, col + 1, row, row + 1)
                num_markers += 1

        self.vboxMarkerLevels.show_all()


    def on_btnRefreshMarkerLevels_clicked(self, button):
        self.maintenance_command('ReportLevels')


    def updateStateReasons(self):
        printer = self.printer
        reasons = printer.other_attributes.get('printer-state-reasons', [])
        store = gtk.ListStore(int, str)
        any = False
        for reason in reasons:
            if reason == 'none':
                break

            any = True
            iter = store.append(None)
            r = statereason.StateReason(printer.name, reason)
            store.set_value(iter, 0, r.get_level())
            (title, text) = r.get_description()
            store.set_value(iter, 1, text)

        self.tvPrinterStateReasons.set_model(store)
        page = 0
        if any:
            page = 1

        self.ntbkPrinterStateReasons.set_current_page(page)


    def set_printer_state_reason_icon(self, column, cell, model, iter, *data):
        level = model.get_value(iter, 0)
        icon = statereason.StateReason.LEVEL_ICON[level]
        theme = gtk.icon_theme_get_default()

        try:
            pixbuf = theme.load_icon(icon, 22, 0)
            cell.set_property('pixbuf', pixbuf)
        except gobject.GError:
            exc = None



    def set_printer_state_reason_text(self, column, cell, model, iter, *data):
        cell.set_property('text', model.get_value(iter, 1))


    def updatePrinterProperties(self):
        debugprint('update printer properties')
        printer = self.printer
        self.lblPMakeModel.set_text(printer.make_and_model)
        state = self.printer_states.get(printer.state, _('Unknown'))
        reason = printer.other_attributes.get('printer-state-message', '')
        if len(reason) > 0:
            state += ' - ' + reason

        self.lblPState.set_text(state)
        if len(self.changed) == 0:
            debugprint('no changes yet: full printer properties update')
            self.chkPEnabled.set_active(printer.enabled)
            self.chkPAccepting.set_active(not (printer.rejecting))
            self.chkPShared.set_active(printer.is_shared)
            (self.fillComboBox(self.cmbPStartBanner, printer.job_sheets_supported, printer.job_sheet_start, ppdippstr.job_sheets),)
            self.fillComboBox(self.cmbPEndBanner, printer.job_sheets_supported, printer.job_sheet_end, ppdippstr.job_sheets)
            self.fillComboBox(self.cmbPErrorPolicy, printer.error_policy_supported, printer.error_policy, ppdippstr.printer_error_policy)
            self.fillComboBox(self.cmbPOperationPolicy, printer.op_policy_supported, printer.op_policy, ppdippstr.printer_op_policy)
            self.rbtnPAllow.set_active(printer.default_allow)
            self.rbtnPDeny.set_active(not (printer.default_allow))
            self.setPUsers(printer.except_users)
            self.updateMarkerLevels()
            self.updateStateReasons()
            self.updatePrinterPropertiesTreeView



    def fillPrinterOptions(self, name, editable):
        tab_nr = self.ntbkPrinter.page_num(self.algnClassMembers)
        if tab_nr != -1:
            self.ntbkPrinter.remove_page(tab_nr)

        for widget in self.vbPInstallOptions.get_children():
            self.vbPInstallOptions.remove(widget)

        for widget in self.vbPOptions.get_children():
            self.vbPOptions.remove(widget)

        if self.ntbkPrinter.page_num(self.swPOptions) == -1:
            self.ntbkPrinter.insert_page(self.swPOptions, self.lblPOptions, self.static_tabs)

        if not self.ppd:
            tab_nr = self.ntbkPrinter.page_num(self.swPInstallOptions)
            if tab_nr != -1:
                self.ntbkPrinter.remove_page(tab_nr)

            tab_nr = self.ntbkPrinter.page_num(self.swPOptions)
            if tab_nr != -1:
                self.ntbkPrinter.remove_page(tab_nr)

            return None
        ppd = self.ppd
        ppd.markDefaults()
        self.ppd_local.markDefaults()
        hasInstallableOptions = False
        for group in self.ppd_local.optionGroups:
            table = gtk.Table(1, 3, False)
            table.set_col_spacings(6)
            table.set_row_spacings(6)
            container.add(table)
            rows = 0
            self.option_inputslot = None
            self.option_manualfeed = None
            for nr, option in enumerate(group.options):
                if option.keyword == 'PageRegion':
                    continue

                rows += 1
                table.resize(rows, 3)
                o = OptionWidget(option, ppd, self, tab_label = tab_label)
                table.attach(o.conflictIcon, 0, 1, nr, nr + 1, 0, 0, 0, 0)
                hbox = gtk.HBox()
                if o.label:
                    a = gtk.Alignment(0.5, 0.5, 1, 1)
                    a.set_padding(0, 0, 0, 6)
                    a.add(o.label)
                    table.attach(a, 1, 2, nr, nr + 1, gtk.FILL, 0, 0, 0)
                    table.attach(hbox, 2, 3, nr, nr + 1, gtk.FILL, 0, 0, 0)
                else:
                    table.attach(hbox, 1, 3, nr, nr + 1, gtk.FILL, 0, 0, 0)
                hbox.pack_start(o.selector, False)
                self.options[option.keyword] = o
                o.selector.set_sensitive(editable)
                if option.keyword == 'InputSlot':
                    self.option_inputslot = o
                    continue
                if option.keyword == 'ManualFeed':
                    self.option_manualfeed = o
                    continue


        if not hasInstallableOptions:
            tab_nr = self.ntbkPrinter.page_num(self.swPInstallOptions)
            if tab_nr != -1:
                self.ntbkPrinter.remove_page(tab_nr)


        for option in self.options.itervalues():
            conflicts = option.checkConflicts()
            if conflicts:
                self.conflicts.add(option)
                continue

        self.swPInstallOptions.show_all()
        self.swPOptions.show_all()


    def fillClassMembers(self, name, editable):
        printer = self.printers[name]
        self.btnClassAddMember.set_sensitive(editable)
        self.btnClassDelMember.set_sensitive(editable)
        tab_nr = self.ntbkPrinter.page_num(self.swPOptions)
        if tab_nr != -1:
            self.ntbkPrinter.remove_page(tab_nr)

        if self.ntbkPrinter.page_num(self.algnClassMembers) == -1:
            self.ntbkPrinter.insert_page(self.algnClassMembers, self.lblClassMembers, self.static_tabs)

        model_members = self.tvClassMembers.get_model()
        model_not_members = self.tvClassNotMembers.get_model()
        model_members.clear()
        model_not_members.clear()
        names = self.printers.keys()
        names.sort()
        for name in names:
            p = self.printers[name]
            if p is not printer:
                if name in printer.class_members:
                    model_members.append((name,))
                else:
                    model_not_members.append((name,))
            name in printer.class_members



    def on_btnClassAddMember_clicked(self, button):
        moveClassMembers(self.tvClassNotMembers, self.tvClassMembers)
        if getCurrentClassMembers(self.tvClassMembers) != self.printer.class_members:
            self.changed.add(self.tvClassMembers)
        else:
            self.changed.discard(self.tvClassMembers)
        self.setDataButtonState()


    def on_btnClassDelMember_clicked(self, button):
        moveClassMembers(self.tvClassMembers, self.tvClassNotMembers)
        if getCurrentClassMembers(self.tvClassMembers) != self.printer.class_members:
            self.changed.add(self.tvClassMembers)
        else:
            self.changed.discard(self.tvClassMembers)
        self.setDataButtonState()


    def on_quit_activate(self, widget, event = None):
        self.monitor.cleanup()
        while len(self.jobviewers) > 0:
            self.jobviewers[0].cleanup()
        gtk.main_quit()


    def is_rename_possible(self, name):
        jobs = self.printers[name].jobsQueued()
        if len(jobs) > 0:
            show_error_dialog(_('Cannot Rename'), _('There are queued jobs.'), parent = self.PrintersWindow)
            return False
        return True


    def on_rename_activate(self, UNUSED):
        tuple = self.dests_iconview.get_cursor()
        if tuple == None:
            return None
        (path, cell) = tuple
        if type(cell) != gtk.CellRendererText:
            cells = self.dests_iconview.get_cells()
            for cell in cells:
                if type(cell) == gtk.CellRendererText:
                    break
                    continue
                tuple == None

            if type(cell) != gtk.CellRendererText:
                return None

        model = self.dests_iconview.get_model()
        iter = model.get_iter(path)
        name = unicode(model.get_value(iter, 2))
        if not self.is_rename_possible(name):
            return None
        cell.set_property('editable', True)
        self.dests_iconview.set_cursor(path, cell, start_editing = True)
        ids = []
        ids.append(cell.connect('edited', self.printer_name_edited))
        ids.append(cell.connect('editing-canceled', self.printer_name_edit_cancel))
        self.rename_sigids = ids


    def printer_name_edited(self, cell, path, newname):
        model = self.dests_iconview.get_model()
        iter = model.get_iter(path)
        name = unicode(model.get_value(iter, 2))
        debugprint('edited: %s -> %s' % (name, newname))

        try:
            self.rename_printer(name, newname)
        finally:
            cell.stop_editing(canceled = False)
            cell.set_property('editable', False)
            for id in self.rename_sigids:
                cell.disconnect(id)




    def printer_name_edit_cancel(self, cell):
        debugprint('editing-canceled')
        cell.stop_editing(canceled = True)
        cell.set_property('editable', False)
        for id in self.rename_sigids:
            cell.disconnect(id)



    def rename_printer(self, old_name, new_name):
        if old_name == new_name:
            return None

        try:
            self.fillPrinterTab(old_name)
        except RuntimeError:
            old_name == new_name
            old_name == new_name
        except:
            old_name == new_name

        if not self.is_rename_possible(old_name):
            return None
        self.cups._begin_operation(_('renaming printer'))
        rejecting = self.printer.rejecting
        if not rejecting:

            try:
                self.printer.setAccepting(False)
                if not self.is_rename_possible(old_name):
                    self.printer.setAccepting(True)
                    self.cups._end_operation()
                    return None
            except cups.IPPError:
                self.is_rename_possible(old_name)
                (e, msg) = self.is_rename_possible(old_name)
                old_name == new_name
                show_IPP_Error(e, msg, self.PrintersWindow)
                self.cups._end_operation()
                return None


        self.is_rename_possible(old_name)<EXCEPTION MATCH>cups.IPPError
        if self.copy_printer(new_name):
            self.monitor.update()
            if not rejecting:

                try:
                    self.printers[old_name].setAccepting(True)
                except cups.HTTPError:
                    self.is_rename_possible(old_name)
                    (s,) = self.is_rename_possible(old_name)
                    self.is_rename_possible(old_name)
                    show_HTTP_Error(s, self.PrintersWindow)
                except cups.IPPError:
                    self.is_rename_possible(old_name)
                    (e, msg) = self.is_rename_possible(old_name)
                    self.is_rename_possible(old_name)
                    show_IPP_Error(e, msg, self.PrintersWindow)
                except:
                    self.is_rename_possible(old_name)<EXCEPTION MATCH>cups.HTTPError


            self.is_rename_possible(old_name)
            self.cups._end_operation()
            return None
        if not rejecting:

            try:
                self.printer.setAccepting(True)
            except cups.HTTPError:
                self.copy_printer(new_name)
                (s,) = self.copy_printer(new_name)
                self.is_rename_possible(old_name)
                show_HTTP_Error(s, self.PrintersWindow)
            except cups.IPPError:
                self.copy_printer(new_name)
                (e, msg) = self.copy_printer(new_name)
                self.copy_printer(new_name)
                show_IPP_Error(e, msg, self.PrintersWindow)
            except:
                self.copy_printer(new_name)<EXCEPTION MATCH>cups.HTTPError


        self.copy_printer(new_name)

        try:
            self.cups.deletePrinter(old_name)
        except cups.HTTPError:
            None if self.default_printer == old_name else old_name == new_name
            (s,) = None if self.default_printer == old_name else old_name == new_name
            show_HTTP_Error(s, self.PrintersWindow)
        except cups.IPPError:
            (e, msg) = None
            show_IPP_Error(e, msg, self.PrintersWindow)
        except:
            None if self.default_printer == old_name else old_name == new_name

        self.cups._end_operation()

        def select_new_printer(model, path, iter):
            name = unicode(model.get_value(iter, 2))
            print name, new_name
            if name == new_name:
                self.dests_iconview.select_path(path)


        self.populateList()
        model = self.dests_iconview.get_model()
        model.foreach(select_new_printer)


    def copy_printer(self, new_name):
        self.printer.name = new_name
        self.printer.class_members = []
        self.cups._begin_operation(_('copying printer'))
        ret = self.save_printer(self.printer, saveall = True, parent = self.PrintersWindow)
        self.cups._end_operation()
        return ret


    def on_copy_activate(self, UNUSED):
        iconview = self.dests_iconview
        paths = iconview.get_selected_items()
        model = self.dests_iconview.get_model()
        iter = model.get_iter(paths[0])
        name = unicode(model.get_value(iter, 2))
        self.entCopyName.set_text(name)
        self.NewPrinterName.set_transient_for(self.PrintersWindow)
        result = self.NewPrinterName.run()
        self.NewPrinterName.hide()
        if result == gtk.RESPONSE_CANCEL:
            return None

        try:
            self.fillPrinterTab(name)
        except RuntimeError:
            result == gtk.RESPONSE_CANCEL
            result == gtk.RESPONSE_CANCEL
        except:
            result == gtk.RESPONSE_CANCEL

        self.copy_printer(self.entCopyName.get_text())
        self.monitor.update()


    def on_entCopyName_changed(self, widget):
        text = unicode(widget.get_text())
        new_text = text
        new_text = new_text.replace('/', '')
        new_text = new_text.replace('#', '')
        new_text = new_text.replace(' ', '')
        if text != new_text:
            widget.set_text(new_text)

        self.btnCopyOk.set_sensitive(self.checkNPName(new_text))


    def on_delete_activate(self, UNUSED):
        if isinstance(self.current_groups_pane_item, StaticGroupItem):
            paths = self.dests_iconview.get_selected_items()
            model = self.dests_iconview.get_model()
            selected_names = []
            for path in paths:
                selected_names.append(model[path][2])

            self.current_groups_pane_item.remove_queues(selected_names)
            self.populateList()
        else:
            self.delete_selected_printer_queues()


    def delete_selected_printer_queues(self):
        paths = self.dests_iconview.get_selected_items()
        model = self.dests_iconview.get_model()
        n = len(paths)
        if n == 1:
            iter = model.get_iter(paths[0])
            object = model.get_value(iter, 0)
            name = model.get_value(iter, 2)
            if object.is_class:
                message_format = _("Really delete class '%s'?") % name
            else:
                message_format = _("Really delete printer '%s'?") % name
        else:
            message_format = _('Really delete selected destinations?')
        dialog = gtk.MessageDialog(self.PrintersWindow, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_NONE, message_format)
        dialog.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_DELETE, gtk.RESPONSE_ACCEPT)
        dialog.set_default_response(gtk.RESPONSE_REJECT)
        result = dialog.run()
        dialog.destroy()
        if result != gtk.RESPONSE_ACCEPT:
            return None

        try:
            for i in range(n):
                iter = model.get_iter(paths[i])
                name = model.get_value(iter, 2)
                self.cups._begin_operation(_('deleting printer %s') % name)
                name = unicode(name)
                self.cups.deletePrinter(name)
                self.cups._end_operation()
        except cups.IPPError:
            result != gtk.RESPONSE_ACCEPT
            (e, msg) = result != gtk.RESPONSE_ACCEPT
            self.cups._end_operation()
            show_IPP_Error(e, msg, self.PrintersWindow)
        except:
            result != gtk.RESPONSE_ACCEPT

        self.changed = set()
        self.monitor.update()


    def on_enabled_activate(self, toggle_action):
        if self.updating_widgets:
            return None
        enable = toggle_action.get_active()
        iconview = self.dests_iconview
        paths = iconview.get_selected_items()
        model = iconview.get_model()
        for i in range(len(paths)):
            iter = model.get_iter(paths[i])
            printer = model.get_value(iter, 0)
            name = unicode(model.get_value(iter, 2), 'utf-8')
            self.cups._begin_operation(_('modifying printer %s') % name)

            try:
                printer.setEnabled(enable)
            except cups.IPPError:
                self.updating_widgets
                (e, m) = self.updating_widgets
                errordialogs.show_IPP_Error(e, m, self.PrintersWindow)
                self.cups._end_operation()
                break
            except:
                self.updating_widgets

            self.cups._end_operation()

        self.monitor.update()


    def on_shared_activate(self, menuitem):
        if self.updating_widgets:
            return None
        share = menuitem.get_active()
        iconview = self.dests_iconview
        paths = iconview.get_selected_items()
        model = iconview.get_model()
        success = False
        for i in range(len(paths)):
            iter = model.get_iter(paths[i])
            printer = model.get_value(iter, 0)
            self.cups._begin_operation(_('modifying printer %s') % printer.name)

            try:
                printer.setShared(share)
                success = True
            except cups.IPPError:
                self.updating_widgets
                (e, m) = self.updating_widgets
                show_IPP_Error(e, m, self.PrintersWindow)
                self.cups._end_operation()
                break
            except:
                self.updating_widgets

            self.cups._end_operation()

        if success and share:
            self.advise_publish()


        def deferred_refresh():
            self.populateList()
            return False

        gobject.idle_add(deferred_refresh)


    def advise_publish(self):
        if not self.server_is_publishing:
            show_info_dialog(_('Publish Shared Printers'), _("Shared printers are not available to other people unless the 'Publish shared printers' option is enabled in the server settings."), parent = self.PrintersWindow)



    def on_set_as_default_activate(self, UNUSED):
        iconview = self.dests_iconview
        paths = iconview.get_selected_items()
        model = iconview.get_model()
        iter = model.get_iter(paths[0])
        name = unicode(model.get_value(iter, 2))
        self.set_system_or_user_default_printer(name)


    def on_edit_activate(self, UNUSED):
        paths = self.dests_iconview.get_selected_items()
        self.dests_iconview_item_activated(self.dests_iconview, paths[0])


    def on_create_class_activate(self, UNUSED):
        paths = self.dests_iconview.get_selected_items()
        class_members = []
        model = self.dests_iconview.get_model()
        for path in paths:
            iter = model.get_iter(path)
            name = unicode(model.get_value(iter, 2), 'utf-8')
            class_members.append(name)

        self.newPrinterGUI.init('class')
        out_model = self.newPrinterGUI.tvNCNotMembers.get_model()
        in_model = self.newPrinterGUI.tvNCMembers.get_model()
        iter = out_model.get_iter_first()
        while iter != None:
            next = out_model.iter_next(iter)
            data = out_model.get(iter, 0)
            if data[0] in class_members:
                in_model.append(data)
                out_model.remove(iter)

            iter = next


    def on_view_print_queue_activate(self, UNUSED):
        paths = self.dests_iconview.get_selected_items()
        if len(paths):
            specific_dests = []
            model = self.dests_iconview.get_model()
            for path in paths:
                iter = model.get_iter(path)
                name = unicode(model.get_value(iter, 2), 'utf-8')
                specific_dests.append(name)

            viewer = jobviewer.JobViewer(None, None, my_jobs = False, specific_dests = specific_dests, exit_handler = self.on_jobviewer_exit, parent = self.PrintersWindow)
        else:
            viewer = jobviewer.JobViewer(None, None, my_jobs = False, exit_handler = self.on_jobviewer_exit, parent = self.PrintersWindow)
        self.jobviewers.append(viewer)


    def on_jobviewer_exit(self, viewer):
        i = self.jobviewers.index(viewer)
        del self.jobviewers[i]


    def on_view_groups_activate(self, widget):
        if widget.get_active():
            if not self.groups_pane_visible:
                self.view_area_vbox.remove(self.view_area_scrolledwindow)
                self.view_area_hpaned.add2(self.view_area_scrolledwindow)
                self.view_area_vbox.add(self.view_area_hpaned)
                self.view_area_vbox.show_all()
                self.groups_pane_visible = True

        elif self.groups_pane_visible:
            self.view_area_vbox.remove(self.view_area_hpaned)
            self.view_area_hpaned.remove(self.view_area_scrolledwindow)
            self.view_area_vbox.add(self.view_area_scrolledwindow)
            self.view_area_vbox.show_all()
            self.groups_pane_visible = False



    def on_view_discovered_printers_activate(self, UNUSED):
        self.populateList()


    def on_troubleshoot_activate(self, widget):
        if not self.__dict__.has_key('troubleshooter'):
            self.troubleshooter = troubleshoot.run(self.on_troubleshoot_quit)



    def on_troubleshoot_quit(self, troubleshooter):
        del self.troubleshooter


    def on_save_as_group_activate(self, UNUSED):
        model = self.dests_iconview.get_model()
        printer_queues = []
        for object in model:
            printer_queues.append(object[2])

        self.groups_pane.create_new_group(printer_queues, self.current_filter_text)


    def on_save_as_search_group_activate(self, UNUSED):
        criterion = None
        if self.current_filter_mode == 'filter-name':
            criterion = SearchCriterion(subject = SearchCriterion.SUBJECT_NAME, value = self.current_filter_text)
        elif self.current_filter_mode == 'filter-description':
            criterion = SearchCriterion(subject = SearchCriterion.SUBJECT_DESC, value = self.current_filter_text)
        elif self.current_filter_mode == 'filter-location':
            criterion = SearchCriterion(subject = SearchCriterion.SUBJECT_LOCATION, value = self.current_filter_text)
        elif self.current_filter_mode == 'filter-manufacturer':
            criterion = SearchCriterion(subject = SearchCriterion.SUBJECT_MANUF, value = self.current_filter_text)
        else:
            nonfatalException()
            return None
        (self.current_filter_mode == 'filter-name').groups_pane.create_new_search_group(criterion, self.current_filter_text)


    def on_about_activate(self, widget):
        self.AboutDialog.set_transient_for(self.PrintersWindow)
        self.AboutDialog.run()
        self.AboutDialog.hide()


    def fillServerTab(self):
        self.changed = set()
        self.cups._begin_operation(_('fetching server settings'))

        try:
            self.server_settings = self.cups.adminGetServerSettings()
        except cups.IPPError:
            (e, m) = None
            show_IPP_Error(e, m, self.PrintersWindow)
            self.cups._end_operation()
            raise

        self.cups._end_operation()
        for widget, setting in [
            (self.chkServerBrowse, cups.CUPS_SERVER_REMOTE_PRINTERS),
            (self.chkServerShare, cups.CUPS_SERVER_SHARE_PRINTERS),
            (self.chkServerShareAny, try_CUPS_SERVER_REMOTE_ANY),
            (self.chkServerRemoteAdmin, cups.CUPS_SERVER_REMOTE_ADMIN),
            (self.chkServerAllowCancelAll, cups.CUPS_SERVER_USER_CANCEL_ANY),
            (self.chkServerLogDebug, cups.CUPS_SERVER_DEBUG_LOGGING)]:
            widget.set_data('setting', setting)
            if self.server_settings.has_key(setting):
                widget.set_active(int(self.server_settings[setting]))
                widget.set_sensitive(True)
                continue
            widget.set_active(False)
            widget.set_sensitive(False)

        self.setDataButtonState()

        try:
            flag = cups.CUPS_SERVER_SHARE_PRINTERS
            publishing = int(self.server_settings[flag])
            self.server_is_publishing = publishing
        except AttributeError:
            pass

        self.on_server_changed(self.chkServerShare)


    def on_server_changed(self, widget):
        setting = widget.get_data('setting')
        if self.server_settings.has_key(setting):
            if str(int(widget.get_active())) == self.server_settings[setting]:
                self.changed.discard(widget)
            else:
                self.changed.add(widget)

        sharing = self.chkServerShare.get_active()
        if sharing:
            pass
        self.chkServerShareAny.set_sensitive(self.server_settings.has_key(try_CUPS_SERVER_REMOTE_ANY))
        self.setDataButtonState()


    def save_serversettings(self):
        setting_dict = self.server_settings.copy()
        for widget, setting in [
            (self.chkServerBrowse, cups.CUPS_SERVER_REMOTE_PRINTERS),
            (self.chkServerShare, cups.CUPS_SERVER_SHARE_PRINTERS),
            (self.chkServerShareAny, try_CUPS_SERVER_REMOTE_ANY),
            (self.chkServerRemoteAdmin, cups.CUPS_SERVER_REMOTE_ADMIN),
            (self.chkServerAllowCancelAll, cups.CUPS_SERVER_USER_CANCEL_ANY),
            (self.chkServerLogDebug, cups.CUPS_SERVER_DEBUG_LOGGING)]:
            if not self.server_settings.has_key(setting):
                continue

            setting_dict[setting] = str(int(widget.get_active()))

        self.cups._begin_operation(_('modifying server settings'))

        try:
            self.cups.adminSetServerSettings(setting_dict)
        except cups.IPPError:
            (e, m) = None
            show_IPP_Error(e, m, self.ServerSettingsDialog)
            self.cups._end_operation()
            return True
            except RuntimeError:
                s = None
                show_IPP_Error(None, s, self.ServerSettingsDialog)
                self.cups._end_operation()
                return True
            else:
                self.cups._end_operation()
                self.changed = set()
                self.setDataButtonState()
                old_setting = self.server_settings.get(cups.CUPS_SERVER_SHARE_PRINTERS, '0')
                new_setting = setting_dict.get(cups.CUPS_SERVER_SHARE_PRINTERS, '0')
                if 0 and old_setting == '0' and new_setting != '0':
                    show_info_dialog(_('Review Firewall'), _('You may need to adjust the firewall to allow network printing to this computer.') + '\n\n' + TEXT_start_firewall_tool, parent = self.ServerSettingsDialog)


        time.sleep(1)
        self.reconnect()

        try:
            self.fillServerTab()
        except:
            nonfatalException()



    def on_problems_button_clicked(self, *args):
        if not self.__dict__.has_key('troubleshooter'):
            self.troubleshooter = troubleshoot.run(self.on_troubleshoot_quit, parent = self.ServerSettingsDialog)



    def on_new_printer_activate(self, widget):
        self.busy(self.PrintersWindow)
        self.newPrinterGUI.init('printer')
        self.ready(self.PrintersWindow)


    def on_autodetected_printer_without_driver(self, widget):
        self.busy(self.PrintersWindow)
        self.newPrinterGUI.init('printer_with_uri')
        self.ready(self.PrintersWindow)


    def on_new_class_activate(self, widget):
        self.newPrinterGUI.init('class')


    def on_btnSelectDevice_clicked(self, button):
        self.busy(self.PrintersWindow)
        self.newPrinterGUI.init('device')
        self.ready(self.PrintersWindow)


    def on_btnChangePPD_clicked(self, button):
        self.busy(self.PrintersWindow)
        self.newPrinterGUI.init('ppd')
        self.ready(self.PrintersWindow)


    def checkNPName(self, name):
        if not name:
            return False
        name = unicode(name.lower())
        for printer in self.printers.values():
            if not (printer.discovered) and printer.name.lower() == name:
                return False

        return True


    def makeNameUnique(self, name):
        '''Make a suggested queue name valid and unique.'''
        name = name.replace(' ', '-')
        name = name.replace('/', '-')
        name = name.replace('#', '-')
        if not self.checkNPName(name):
            suffix = 2
            while not self.checkNPName(name + str(suffix)):
                suffix += 1
                if suffix == 100:
                    break
                    continue
            name += str(suffix)

        return name


    def printer_added_or_removed(self):
        gtk.gdk.threads_enter()
        self.populateList(prompt_allowed = False)
        gtk.gdk.threads_leave()


    def printer_added(self, mon, printer):
        monitor.Watcher.printer_added(self, mon, printer)
        self.printer_added_or_removed()


    def printer_event(self, mon, printer, eventname, event):
        monitor.Watcher.printer_event(self, mon, printer, eventname, event)
        gtk.gdk.threads_enter()
        if self.PrinterPropertiesDialog.get_property('visible'):
            self.printer.getAttributes()
            self.updatePrinterProperties()

        gtk.gdk.threads_leave()


    def printer_removed(self, mon, printer):
        monitor.Watcher.printer_removed(self, mon, printer)
        self.printer_added_or_removed()


    def state_reason_added(self, mon, reason):
        monitor.Watcher.state_reason_added(self, mon, reason)
        gtk.gdk.threads_enter()
        if self.PrinterPropertiesDialog.get_property('visible'):
            self.printer.getAttributes()
            self.updatePrinterProperties()

        gtk.gdk.threads_leave()


    def state_reason_removed(self, mon, reason):
        monitor.Watcher.state_reason_removed(self, mon, reason)
        gtk.gdk.threads_enter()
        if self.PrinterPropertiesDialog.get_property('visible'):
            self.printer.getAttributes()
            self.updatePrinterProperties()

        gtk.gdk.threads_leave()


    def cups_connection_error(self, mon):
        monitor.Watcher.cups_connection_error(self, mon)

        try:
            self.cups.getClasses()
        except:
            self.cups = None
            gtk.gdk.threads_enter()
            self.setConnected()
            self.populateList(prompt_allowed = False)
            gtk.gdk.threads_leave()




class NewPrinterGUI(GtkGUI):
    new_printer_device_tabs = {
        'parallel': 0,
        'usb': 0,
        'hal': 0,
        'beh': 0,
        'hp': 8,
        'hpfax': 0,
        'socket': 2,
        'ipp': 3,
        'http': 3,
        'lpd': 4,
        'scsi': 5,
        'serial': 6,
        'smb': 7,
        'network': 9 }
    DOWNLOADABLE_ONLYPPD = True
    HP_PLUGIN_SUPPORT = True

    def __init__(self, mainapp):
        self.mainapp = mainapp
        self.tooltips = mainapp.tooltips
        self.language = mainapp.language
        self.options = { }
        self.changed = set()
        self.conflicts = set()
        self.ppd = None
        self.remotecupsqueue = False
        self.exactdrivermatch = False
        self.installable_options = False
        self.jockey_installed_files = []
        self.jockey_lock = thread.allocate_lock()
        self.ppds_lock = thread.allocate_lock()
        self.ipp_lock = thread.allocate_lock()
        self.drivers_lock = thread.allocate_lock()
        self.getWidgets({
            'NewPrinterWindow': [
                'NewPrinterWindow',
                'ntbkNewPrinter',
                'btnNPBack',
                'btnNPForward',
                'btnNPApply',
                'entNPName',
                'entNPDescription',
                'entNPLocation',
                'tvNPDevices',
                'ntbkNPType',
                'lblNPDeviceDescription',
                'expNPDeviceURIs',
                'tvNPDeviceURIs',
                'cmbNPTSerialBaud',
                'cmbNPTSerialParity',
                'cmbNPTSerialBits',
                'cmbNPTSerialFlow',
                'cmbentNPTLpdHost',
                'cmbentNPTLpdQueue',
                'entNPTIPPHostname',
                'btnIPPFindQueue',
                'lblIPPURI',
                'entNPTIPPQueuename',
                'btnIPPVerify',
                'entNPTDirectJetHostname',
                'entNPTDirectJetPort',
                'entSMBURI',
                'btnSMBBrowse',
                'tblSMBAuth',
                'rbtnSMBAuthPrompt',
                'rbtnSMBAuthSet',
                'entSMBUsername',
                'entSMBPassword',
                'btnSMBVerify',
                'entNPTHPHostname',
                'btnHPFindQueue',
                'entNPTNetworkHostname',
                'btnNetworkFind',
                'lblHPURI',
                'entNPTDevice',
                'tvNCMembers',
                'tvNCNotMembers',
                'ntbkPPDSource',
                'rbtnNPPPD',
                'tvNPMakes',
                'rbtnNPFoomatic',
                'filechooserPPD',
                'rbtnNPDownloadableDriverSearch',
                'entNPDownloadableDriverSearch',
                'btnNPDownloadableDriverSearch',
                'cmbNPDownloadableDriverFoundPrinters',
                'tvNPModels',
                'tvNPDrivers',
                'rbtnChangePPDasIs',
                'rbtnChangePPDKeepSettings',
                'scrNPInstallableOptions',
                'vbNPInstallOptions',
                'tvNPDownloadableDrivers',
                'ntbkNPDownloadableDriverProperties',
                'lblNPDownloadableDriverSupplier',
                'cbNPDownloadableDriverSupplierVendor',
                'lblNPDownloadableDriverLicense',
                'cbNPDownloadableDriverLicensePatents',
                'cbNPDownloadableDriverLicenseFree',
                'lblNPDownloadableDriverDescription',
                'lblNPDownloadableDriverSupportContacts',
                'hsDownloadableDriverPerfText',
                'hsDownloadableDriverPerfLineArt',
                'hsDownloadableDriverPerfGraphics',
                'hsDownloadableDriverPerfPhoto',
                'lblDownloadableDriverPerfTextUnknown',
                'lblDownloadableDriverPerfLineArtUnknown',
                'lblDownloadableDriverPerfGraphicsUnknown',
                'lblDownloadableDriverPerfPhotoUnknown',
                'frmNPDownloadableDriverLicenseTerms',
                'tvNPDownloadableDriverLicense',
                'rbtnNPDownloadLicenseYes',
                'rbtnNPDownloadLicenseNo'],
            'IPPBrowseDialog': [
                'IPPBrowseDialog',
                'tvIPPBrowser',
                'btnIPPBrowseOk'],
            'SMBBrowseDialog': [
                'SMBBrowseDialog',
                'tvSMBBrowser',
                'btnSMBBrowseOk'],
            'InstallDialog': [
                'InstallDialog',
                'lblInstall'] })
        for dialog in [
            self.IPPBrowseDialog,
            self.SMBBrowseDialog]:
            dialog.connect('delete-event', on_delete_just_hide)

        self.WaitWindow = mainapp.WaitWindow
        self.lblWait = mainapp.lblWait
        self.busy = mainapp.busy
        self.ready = mainapp.ready
        gtk_label_autowrap.set_autowrap(self.NewPrinterWindow)
        self.ntbkNewPrinter.set_show_tabs(False)
        self.ntbkPPDSource.set_show_tabs(False)
        self.ntbkNPType.set_show_tabs(False)
        self.ntbkNPDownloadableDriverProperties.set_show_tabs(False)
        self.openprinting = cupshelpers.openprinting.OpenPrinting()
        self.openprinting_query_handle = None
        combobox = self.cmbNPDownloadableDriverFoundPrinters
        cell = gtk.CellRendererText()
        combobox.pack_start(cell, True)
        combobox.add_attribute(cell, 'text', 0)
        if self.DOWNLOADABLE_ONLYPPD:
            for widget in [
                self.cbNPDownloadableDriverLicenseFree,
                self.cbNPDownloadableDriverLicensePatents]:
                widget.hide()



        def protect_toggle(toggle_widget):
            active = toggle_widget.get_data('protect_active')
            if active != None:
                toggle_widget.set_active(active)


        for widget in [
            self.cbNPDownloadableDriverSupplierVendor,
            self.cbNPDownloadableDriverLicenseFree,
            self.cbNPDownloadableDriverLicensePatents]:
            widget.connect('clicked', protect_toggle)

        for widget in [
            self.hsDownloadableDriverPerfText,
            self.hsDownloadableDriverPerfLineArt,
            self.hsDownloadableDriverPerfGraphics,
            self.hsDownloadableDriverPerfPhoto]:
            widget.connect('change-value', (lambda x, y, z: True))

        slct = self.tvNPDevices.get_selection()
        slct.set_select_function(self.device_select_function)
        self.tvNPDevices.set_row_separator_func(self.device_row_separator_fn)
        self.tvNPDevices.connect('row-activated', self.device_row_activated)
        self.expNPDeviceURIs.connect('notify::expanded', self.on_expNPDeviceURIs_expanded)
        self.smb_store = gtk.TreeStore(gobject.TYPE_PYOBJECT)
        self.btnSMBBrowse.set_sensitive(PYSMB_AVAILABLE)
        if not PYSMB_AVAILABLE:
            self.btnSMBBrowse.set_tooltip_text(_('Browsing not available (pysmbc not installed)'))

        self.tvSMBBrowser.set_model(self.smb_store)
        col = gtk.TreeViewColumn(_('Share'))
        cell = gtk.CellRendererText()
        col.pack_start(cell, False)
        col.set_cell_data_func(cell, self.smbbrowser_cell_share)
        self.tvSMBBrowser.append_column(col)
        col = gtk.TreeViewColumn(_('Comment'))
        cell = gtk.CellRendererText()
        col.pack_start(cell, False)
        col.set_cell_data_func(cell, self.smbbrowser_cell_comment)
        self.tvSMBBrowser.append_column(col)
        slct = self.tvSMBBrowser.get_selection()
        slct.set_select_function(self.smb_select_function)
        self.SMBBrowseDialog.set_transient_for(self.NewPrinterWindow)
        self.ipp_store = gtk.TreeStore(str, str, gobject.TYPE_PYOBJECT)
        self.tvIPPBrowser.set_model(self.ipp_store)
        self.ipp_store.set_sort_column_id(0, gtk.SORT_ASCENDING)
        col = gtk.TreeViewColumn(_('Queue'), gtk.CellRendererText(), text = 0)
        col.set_resizable(True)
        col.set_sort_column_id(0)
        self.tvIPPBrowser.append_column(col)
        col = gtk.TreeViewColumn(_('Location'), gtk.CellRendererText(), text = 1)
        self.tvIPPBrowser.append_column(col)
        self.IPPBrowseDialog.set_transient_for(self.NewPrinterWindow)
        self.tvNPDriversTooltips = TreeViewTooltips(self.tvNPDrivers, self.NPDriversTooltips)
        ppd_filter = gtk.FileFilter()
        ppd_filter.set_name(_('PostScript Printer Description files (*.ppd, *.PPD, *.ppd.gz, *.PPD.gz, *.PPD.GZ)'))
        ppd_filter.add_pattern('*.ppd')
        ppd_filter.add_pattern('*.PPD')
        ppd_filter.add_pattern('*.ppd.gz')
        ppd_filter.add_pattern('*.PPD.gz')
        ppd_filter.add_pattern('*.PPD.GZ')
        self.filechooserPPD.add_filter(ppd_filter)
        ppd_filter = gtk.FileFilter()
        ppd_filter.set_name(_('All files (*)'))
        ppd_filter.add_pattern('*')
        self.filechooserPPD.add_filter(ppd_filter)


    def show_IPP_Error(self, exception, message):
        return show_IPP_Error(exception, message, parent = self.NewPrinterWindow)


    def option_changed(self, option):
        if option.is_changed():
            self.changed.add(option)
        else:
            self.changed.discard(option)
        if option.conflicts:
            self.conflicts.add(option)
        else:
            self.conflicts.discard(option)
        self.setDataButtonState()


    def setDataButtonState(self):
        self.btnNPForward.set_sensitive(not bool(self.conflicts))


    def init(self, dialog_mode):
        self.dialog_mode = dialog_mode
        self.options = { }
        self.changed = set()
        self.conflicts = set()
        combobox = self.cmbNPDownloadableDriverFoundPrinters
        combobox.set_model(gtk.ListStore(str, str))
        self.entNPDownloadableDriverSearch.set_text('')
        button = self.btnNPDownloadableDriverSearch
        label = button.get_children()[0].get_children()[0].get_children()[1]
        self.btnNPDownloadableDriverSearch_label = label
        label.set_text(_('Search'))
        if self.dialog_mode in ('printer', 'printer_with_uri', 'class'):
            if self.dialog_mode == 'class':
                name_proto = 'class'
            else:
                name_proto = 'printer'
            self.entNPName.set_text(self.mainapp.makeNameUnique(name_proto))
            self.entNPName.grab_focus()
            for widget in [
                self.entNPLocation,
                self.entNPDescription,
                self.entSMBURI,
                self.entSMBUsername,
                self.entSMBPassword]:
                widget.set_text('')


        if self.dialog_mode == 'printer_with_uri':
            device_dict = { }
            self.device = cupshelpers.Device(self.mainapp.device_uri, **device_dict)

        self.entNPTDirectJetPort.set_text('9100')
        if self.dialog_mode == 'printer':
            self.NewPrinterWindow.set_title(_('New Printer'))
            self.ntbkNewPrinter.set_current_page(1)
            self.fillDeviceTab()
            self.rbtnNPFoomatic.set_active(True)
            self.on_rbtnNPFoomatic_toggled(self.rbtnNPFoomatic)
            self.new_printer_PPDs_loaded = False
            self.queryPPDs()
        elif self.dialog_mode == 'class':
            self.NewPrinterWindow.set_title(_('New Class'))
            self.fillNewClassMembers()
            self.ntbkNewPrinter.set_current_page(0)
        elif self.dialog_mode == 'device':
            self.NewPrinterWindow.set_title(_('Change Device URI'))
            self.ntbkNewPrinter.set_current_page(1)
            self.fillDeviceTab(self.mainapp.printer.device_uri)
        elif self.dialog_mode == 'ppd' or self.dialog_mode == 'printer_with_uri':
            if self.dialog_mode == 'ppd':
                self.NewPrinterWindow.set_title(_('Change Driver'))
            else:
                self.NewPrinterWindow.set_title(_('New Printer'))
            self.ntbkNewPrinter.set_current_page(2)
            self.rbtnNPFoomatic.set_active(True)
            self.on_rbtnNPFoomatic_toggled(self.rbtnNPFoomatic)
            self.rbtnChangePPDKeepSettings.set_active(True)
            self.auto_model = ''
            ppd = self.mainapp.ppd
            devid = self.mainapp.devid
            if devid != '':

                try:
                    devid_dict = cupshelpers.parseDeviceID(devid)
                    self.loadPPDs()
                    reloaded = 0
                    while reloaded < 2:
                        (status, ppdname) = self.ppds.getPPDNameFromDeviceID(devid_dict['MFG'], devid_dict['MDL'], devid_dict['DES'], devid_dict['CMD'], uri, self.jockey_installed_files)
                        if status != self.ppds.STATUS_SUCCESS and reloaded == 0:
                            if self.fetchJockeyDriver():

                                try:
                                    self.dropPPDs()
                                    self.loadPPDs()
                                    reloaded = 1
                                reloaded = 2

                            else:
                                reloaded = 2
                        self.fetchJockeyDriver()
                        reloaded = 2
                        continue
                        None if self.dialog_mode == 'ppd' else self.install_hplip_plugin(uri)
                    if ppdname:
                        ppddict = self.ppds.getInfoFromPPDName(ppdname)
                        make_model = ppddict['ppd-make-and-model']
                        (self.auto_make, self.auto_model) = cupshelpers.ppds.ppdMakeModelSplit(make_model)
                        if status == self.ppds.STATUS_SUCCESS and self.dialog_mode != 'ppd':
                            self.exactdrivermatch = True
                            self.fillMakeList()
                            self.ntbkNewPrinter.set_current_page(6)
                            self.nextNPTab(step = 0)
                        else:
                            self.exactdrivermatch = False
                    else:
                        self.auto_make = devid_dict['MFG']
                        self.auto_model = devid_dict['MDL']
                except:
                    None if self.dialog_mode == 'ppd' else self.install_hplip_plugin(uri)
                    self.auto_make = devid_dict['MFG']
                    self.auto_model = devid_dict['MDL']

                self.mainapp.devid = ''
            elif ppd:
                attr = ppd.findAttr('Manufacturer')
                if attr:
                    mfr = attr.value
                else:
                    mfr = ''
                makeandmodel = mfr
                attr = ppd.findAttr('ModelName')
                if not attr:
                    attr = ppd.findAttr('ShortNickName')

                if not attr:
                    attr = ppd.findAttr('NickName')

                if attr:
                    if attr.value.startswith(mfr):
                        makeandmodel = attr.value
                    else:
                        makeandmodel += ' ' + attr.value
                else:
                    makeandmodel = ''
                (self.auto_make, self.auto_model) = cupshelpers.ppds.ppdMakeModelSplit(makeandmodel)
            else:
                self.auto_make = 'Raw'
                self.auto_model = 'Queue'

            try:
                self.loadPPDs()
            except cups.IPPError:
                (e, m) = None
                show_IPP_Error(e, m, parent = self.mainapp.PrintersWindow)
                return None
                return None

            self.fillMakeList()

        self.setNPButtons()
        self.NewPrinterWindow.show()


    def queryJockeyDriver(self):
        debugprint('queryJockeyDriver')
        if not self.jockey_lock.acquire(0):
            debugprint('queryJockeyDriver: in progress')
            return None
        debugprint('Lock acquired for Jockey driver thread')
        devid = ''

        try:
            devid = self.device.id
        except:
            self.jockey_lock.acquire(0)

        if devid == '':
            self.jockey_lock.release()
            return None
        thread.start_new_thread(self.getJockeyDriver_thread, (devid,))
        debugprint('Jockey driver thread started')


    def getJockeyDriver_thread(self, id):
        debugprint('Requesting driver from Jockey: %s' % id)
        self.jockey_driver_result = False
        self.jockey_installed_files = []

        try:
            bus = dbus.SessionBus()
            obj = bus.get_object('com.ubuntu.DeviceDriver', '/GUI')
            jockeyloader = dbus.Interface(obj, 'com.ubuntu.DeviceDriver')
            (result, installedfiles) = jockeyloader.search_driver('printer_deviceid:%s' % id, timeout = 999999)
            self.jockey_driver_result = result
            self.jockey_installed_files = installedfiles
            if result:
                debugprint('New driver downloaded and installed')
            else:
                debugprint('No new driver found or download rejected')
        except dbus.DBusException:
            e = None
            self.jockey_driver_result = 'D-Bus Error: %s' % e
            debugprint(self.jockey_driver_result)
        except Exception:
            e = None
            nonfatalException()
            self.jockey_driver_result = e
            debugprint('Non-D-Bus error on Jockey call: %s' % e)

        debugprint('Releasing Jockey driver lock')
        self.jockey_lock.release()


    def fetchJockeyDriver(self, parent = None):
        debugprint('fetchJockeyDriver')
        self.queryJockeyDriver()
        time.sleep(0.1)
        waiting = False
        while self.jockey_lock.locked():
            if not waiting:
                waiting = True
                self.lblWait.set_markup('<span weight="bold" size="larger">' + _('Searching') + '</span>\n\n' + _('Searching for downloadable drivers'))
                if not parent:
                    parent = self.mainapp.PrintersWindow

                self.WaitWindow.set_transient_for(parent)
                self.WaitWindow.show()

            while gtk.events_pending():
                gtk.main_iteration()
            time.sleep(0.1)
        if waiting:
            self.WaitWindow.hide()

        debugprint('Driver download request finished')
        result = self.jockey_driver_result
        if isinstance(result, Exception):
            raise result
        isinstance(result, Exception)
        return result


    def queryPPDs(self):
        debugprint('queryPPDs')
        if not self.ppds_lock.acquire(0):
            debugprint('queryPPDs: in progress')
            return None
        debugprint('Lock acquired for PPDs thread')
        thread.start_new_thread(self.getPPDs_thread, (self.language[0],))
        debugprint('PPDs thread started')


    def getPPDs_thread(self, language):

        try:
            debugprint('Connecting (PPDs)')
            cups.setUser(self.mainapp.connect_user)
            cups.setPasswordCB((lambda x: ''))
            c = cups.Connection(host = self.mainapp.connect_server, encryption = self.mainapp.connect_encrypt)
            debugprint('Fetching PPDs')
            ppds_dict = c.getPPDs()
            self.ppds_result = cupshelpers.ppds.PPDs(ppds_dict, language = language)
            debugprint('Closing connection (PPDs)')
            del c
        except cups.IPPError:
            (e, msg) = None
            self.ppds_result = cups.IPPError(e, msg)
        except Exception:
            e = None
            nonfatalException()
            self.ppds_result = e

        debugprint('Releasing PPDs lock')
        self.ppds_lock.release()


    def fetchPPDs(self, parent = None):
        debugprint('fetchPPDs')
        self.queryPPDs()
        waiting = False
        while self.ppds_lock.locked():
            if not waiting:
                waiting = True
                self.lblWait.set_markup('<span weight="bold" size="larger">' + _('Searching') + '</span>\n\n' + _('Searching for drivers'))
                if not parent:
                    parent = self.mainapp.PrintersWindow

                self.WaitWindow.set_transient_for(parent)
                self.WaitWindow.show_now()

            while gtk.events_pending():
                gtk.main_iteration()
            time.sleep(0.1)
        if waiting:
            self.WaitWindow.hide()

        debugprint('Got PPDs')
        result = self.ppds_result
        if isinstance(result, Exception):
            raise result
        isinstance(result, Exception)
        return result


    def loadPPDs(self, parent = None):

        try:
            return self.ppds
        except:
            self.ppds = self.fetchPPDs(parent = parent)
            return self.ppds



    def dropPPDs(self):

        try:
            del self.ppds
        except:
            pass



    def fillNewClassMembers(self):
        model = self.tvNCMembers.get_model()
        model.clear()
        model = self.tvNCNotMembers.get_model()
        model.clear()
        for printer in self.mainapp.printers.itervalues():
            model.append((printer.name,))



    def on_btnNCAddMember_clicked(self, button):
        moveClassMembers(self.tvNCNotMembers, self.tvNCMembers)
        self.btnNPApply.set_sensitive(bool(getCurrentClassMembers(self.tvNCMembers)))


    def on_btnNCDelMember_clicked(self, button):
        moveClassMembers(self.tvNCMembers, self.tvNCNotMembers)
        self.btnNPApply.set_sensitive(bool(getCurrentClassMembers(self.tvNCMembers)))


    def on_NPCancel(self, widget, event = None):
        self.NewPrinterWindow.hide()
        if self.openprinting_query_handle != None:
            self.openprinting.cancelOperation(self.openprinting_query_handle)
            self.openprinting_query_handle = None

        return True


    def on_btnNPBack_clicked(self, widget):
        self.nextNPTab(-1)


    def on_btnNPForward_clicked(self, widget):
        self.nextNPTab()


    def nextNPTab(self, step = 1):
        page_nr = self.ntbkNewPrinter.get_current_page()
        if self.dialog_mode == 'class':
            order = [
                0,
                4,
                5]
        elif self.dialog_mode == 'printer' or self.dialog_mode == 'printer_with_uri':
            self.busy(self.NewPrinterWindow)
            if page_nr == 1:
                (self.auto_make, self.auto_model) = (None, None)
                self.device.uri = self.getDeviceURI()
                if not self.install_hplip_plugin(self.device.uri):
                    self.on_NPCancel(None)
                    return None
                uri = self.device.uri
                if uri and uri.startswith('smb://'):
                    uri = SMBURI(uri = uri[6:]).sanitize_uri()

                self.remotecupsqueue = None
                res = re.search('ipp://(\\S+(:\\d+|))/printers/(\\S+)', uri)
                if res:
                    resg = res.groups()

                    try:
                        conn = httplib.HTTPConnection(resg[0])
                        conn.request('GET', '/printers/%s.ppd' % resg[2])
                        resp = conn.getresponse()
                        if resp.status == 200:
                            self.remotecupsqueue = resg[2]
                    except:
                        pass


                    try:
                        if len(resg[1]) > 0:
                            port = int(resg[1])
                        else:
                            port = 631
                        encryption = cups.HTTP_ENCRYPT_IF_REQUESTED
                        c = cups.Connection(host = resg[0], port = port, encryption = encryption)
                        r = [
                            'printer-info',
                            'printer-location']
                        attrs = c.getPrinterAttributes(uri = uri, requested_attributes = r)
                        info = attrs.get('printer-info', '')
                        location = attrs.get('printer-location', '')
                        if len(info) > 0:
                            self.entNPDescription.set_text(info)

                        if len(location) > 0:
                            self.entNPLocation.set_text(location)
                    nonfatalException()


                if not (self.remotecupsqueue) and not (self.new_printer_PPDs_loaded):

                    try:
                        self.loadPPDs(self.NewPrinterWindow)
                    except cups.IPPError:
                        (e, msg) = None
                        self.ready(self.NewPrinterWindow)
                        self.show_IPP_Error(e, msg)
                        return None
                        self.ready(self.NewPrinterWindow)
                        return None

                    self.new_printer_PPDs_loaded = True

                ppdname = None

                try:
                    if self.remotecupsqueue:
                        ppdname = 'raw'
                        self.ppd = ppdname
                        name = self.remotecupsqueue
                        name = self.mainapp.makeNameUnique(name)
                        self.entNPName.set_text(name)
                    elif self.device.id:
                        id_dict = self.device.id_dict
                        reloaded = 0
                        while reloaded < 2:
                            (status, ppdname) = self.ppds.getPPDNameFromDeviceID(id_dict['MFG'], id_dict['MDL'], id_dict['DES'], id_dict['CMD'], self.device.uri, self.jockey_installed_files)
                            if status != self.ppds.STATUS_SUCCESS and reloaded == 0:
                                if self.fetchJockeyDriver():

                                    try:
                                        self.dropPPDs()
                                        self.loadPPDs()
                                        reloaded = 1
                                    reloaded = 2

                                else:
                                    reloaded = 2
                            self.fetchJockeyDriver()
                            reloaded = 2
                    else:
                        (status, ppdname) = self.ppds.getPPDNameFromDeviceID('Generic', 'Printer', 'Generic Printer', [], self.device.uri)
                    if ppdname and not (self.remotecupsqueue):
                        ppddict = self.ppds.getInfoFromPPDName(ppdname)
                        make_model = ppddict['ppd-make-and-model']
                        (make, model) = cupshelpers.ppds.ppdMakeModelSplit(make_model)
                        self.auto_make = make
                        self.auto_model = model
                        if status == self.ppds.STATUS_SUCCESS and self.dialog_mode != 'ppd':
                            self.exactdrivermatch = True
                        else:
                            self.exactdrivermatch = False
                except:
                    nonfatalException()

                if not self.remotecupsqueue:
                    self.fillMakeList()

            elif page_nr == 3:
                if not self.device.id:

                    try:
                        (model, iter) = self.tvNPModels.get_selection().get_selected()
                        name = model.get(iter, 0)[0]
                        name = self.mainapp.makeNameUnique(name)
                        self.entNPName.set_text(name)
                    nonfatalException()



            self.ready(self.NewPrinterWindow)
            if self.dialog_mode == 'printer':
                if self.remotecupsqueue:
                    order = [
                        1,
                        0]
                elif self.exactdrivermatch:
                    order = [
                        1,
                        6,
                        0]
                elif self.rbtnNPFoomatic.get_active():
                    order = [
                        1,
                        2,
                        3,
                        6,
                        0]
                elif self.rbtnNPPPD.get_active():
                    order = [
                        1,
                        2,
                        6,
                        0]
                else:
                    order = [
                        1,
                        2,
                        7,
                        6,
                        0]
            elif self.remotecupsqueue:
                order = [
                    0]
            elif self.exactdrivermatch:
                order = [
                    6,
                    0]
            elif self.rbtnNPFoomatic.get_active():
                order = [
                    2,
                    3,
                    6,
                    0]
            elif self.rbtnNPPPD.get_active():
                order = [
                    2,
                    6,
                    0]
            else:
                order = [
                    2,
                    7,
                    6,
                    0]
        elif self.dialog_mode == 'device':
            order = [
                1]
        elif self.dialog_mode == 'ppd':
            if self.rbtnNPFoomatic.get_active():
                order = [
                    2,
                    3,
                    5,
                    6]
            elif self.rbtnNPPPD.get_active():
                order = [
                    2,
                    5,
                    6]
            else:
                order = [
                    2,
                    7,
                    5,
                    6]

        next_page_nr = order[order.index(page_nr) + step]
        fetch_ppd = False

        try:
            if order.index(5) > -1:
                if next_page_nr == 5:
                    pass
                fetch_ppd = step >= 0
        except ValueError:
            if next_page_nr == 6:
                pass
            fetch_ppd = step >= 0

        debugprint('Will fetch ppd? %d' % fetch_ppd)
        if fetch_ppd:
            self.ppd = self.getNPPPD()
            self.installable_options = False
            if self.ppd == None:
                return None
            if isinstance(self.ppd, cups.PPD):
                self.fillNPInstallableOptions()
            else:
                ppd = self.ppd
                self.ppd = None
                self.fillNPInstallableOptions()
                self.ppd = ppd
            if not self.installable_options:
                if next_page_nr == 6:
                    next_page_nr = order[order.index(next_page_nr) + 1]



        if next_page_nr == 6 and not (self.installable_options) and step < 0:
            next_page_nr = order[order.index(next_page_nr) - 1]

        if step >= 0 and next_page_nr == 7:
            if self.drivers_lock.locked():
                self.lblWait.set_markup('<span weight="bold" size="larger">' + _('Searching') + '</span>\n\n' + _('Searching for drivers'))
                self.WaitWindow.set_transient_for(self.NewPrinterWindow)
                self.WaitWindow.show()
                self.busy(self.NewPrinterWindow)
                while self.drivers_lock.locked():
                    while gtk.events_pending():
                        gtk.main_iteration()
                    time.sleep(0.1)
                self.ready(self.NewPrinterWindow)
                self.WaitWindow.hide()

            self.fillDownloadableDrivers()

        if step >= 0 and next_page_nr == 0:
            name = None
            descr = None

            try:
                if self.device.id and self.device.type not in ('socket', 'lpd', 'ipp', 'bluetooth'):
                    name = self.device.id_dict['MDL']
                    descr = '%s %s' % (self.device.id_dict['MFG'], self.device.id_dict['MDL'])
            except:
                nonfatalException()


            try:
                if name == None and isinstance(self.ppd, cups.PPD):
                    mname = self.ppd.findAttr('modelName').value
                    (make, model) = cupshelpers.ppds.ppdMakeModelSplit(mname)
                    name = '%s %s' % (make, model)
                    descr = '%s %s' % (make, model)
            except:
                nonfatalException()

            if name == None:
                name = 'printer'

            name = self.mainapp.makeNameUnique(name)
            self.entNPName.set_text(name)
            if self.entNPDescription.get_text() == '' and descr:
                self.entNPDescription.set_text(descr)


        self.ntbkNewPrinter.set_current_page(next_page_nr)
        self.setNPButtons()


    def setNPButtons(self):
        nr = self.ntbkNewPrinter.get_current_page()
        if self.dialog_mode == 'device':
            self.btnNPBack.hide()
            self.btnNPForward.hide()
            self.btnNPApply.show()

            try:
                uri = self.getDeviceURI()
                valid = validDeviceURI(uri)
            except AttributeError:
                valid = False

            self.btnNPApply.set_sensitive(valid)
            return None
        self.btnNPForward.show()
        self.btnNPApply.hide()
        if nr == 2:
            downloadable_selected = False
            if self.rbtnNPDownloadableDriverSearch.get_active():
                combobox = self.cmbNPDownloadableDriverFoundPrinters
                iter = combobox.get_active_iter()
                if iter and combobox.get_model().get_value(iter, 1):
                    downloadable_selected = True


            if not self.rbtnNPFoomatic.get_active() and self.filechooserPPD.get_filename():
                pass
            self.btnNPForward.set_sensitive(bool(downloadable_selected))
            if self.dialog_mode == 'printer_with_uri':
                self.btnNPBack.hide()


        if nr == 3:
            (model, iter) = self.tvNPDrivers.get_selection().get_selected()
            self.btnNPForward.set_sensitive(bool(iter))

        if nr == 4:
            self.btnNPForward.hide()
            self.btnNPApply.show()
            self.btnNPApply.set_sensitive(bool(getCurrentClassMembers(self.tvNCMembers)))

        if nr == 6:
            if self.dialog_mode == 'printer_with_uri' and self.exactdrivermatch:
                self.btnNPBack.hide()


        if nr == 7:
            if self.ntbkNPDownloadableDriverProperties.get_current_page() == 1:
                accepted = self.rbtnNPDownloadLicenseYes.get_active()
            else:
                treeview = self.tvNPDownloadableDrivers
                (model, iter) = treeview.get_selection().get_selected()
                accepted = iter != None
            self.btnNPForward.set_sensitive(accepted)



    def on_entNPName_changed(self, widget):
        text = unicode(widget.get_text())
        new_text = text
        new_text = new_text.replace('/', '')
        new_text = new_text.replace('#', '')
        new_text = new_text.replace(' ', '')
        if text != new_text:
            widget.set_text(new_text)

        if self.dialog_mode == 'printer':
            self.btnNPApply.set_sensitive(self.mainapp.checkNPName(new_text))
        else:
            self.btnNPForward.set_sensitive(self.mainapp.checkNPName(new_text))


    def fetchDevices(self, parent = None):
        debugprint('fetchDevices')
        self.lblWait.set_markup('<span weight="bold" size="larger">' + _('Searching') + '</span>\n\n' + _('Searching for printers'))
        if parent == None:
            parent = self.mainapp.PrintersWindow

        self.WaitWindow.set_transient_for(parent)
        self.WaitWindow.show_now()
        while gtk.events_pending():
            gtk.main_iteration()
        debugprint('Fetching devices')
        self.mainapp.cups._begin_operation(_('fetching device list'))

        try:
            devices = cupshelpers.getDevices(self.mainapp.cups)
        except:
            self.mainapp.cups._end_operation()
            self.WaitWindow.hide()
            raise

        self.mainapp.cups._end_operation()
        self.WaitWindow.hide()
        debugprint('Got devices')
        return devices


    def install_hplip_plugin(self, uri):
        '''
        Attempt to install a plugin using hp-plugin.

        @return: True if plugin not needed (or needed and installed),
        False on error.
        '''
        if not self.HP_PLUGIN_SUPPORT:
            return True
        os.environ['URI'] = uri
        cmd = 'LC_ALL=C DISPLAY= hp-info -d"${URI}"'
        debugprint(uri + ': ' + cmd)

        try:
            p = subprocess.Popen(cmd, shell = True, stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
            (stdout, stderr) = p.communicate()
        except:
            self.HP_PLUGIN_SUPPORT
            return True

        plugin_needed = -1
        plugin_reason = -1
        fw_download = -1
        hplip_version = None
        for line in stdout.split('\n'):
            if line.find('plugin ') >= 0:
                res = re.search('(\\d+)', line)
                if res:
                    resg = res.groups()
                    plugin_needed = int(resg[0])

            elif line.find('plugin-reason') >= 0:
                res = re.search('(\\d+)', line)
                if res:
                    resg = res.groups()
                    plugin_reason = int(resg[0])

            elif line.find('fw-download') >= 0:
                if line.find('True') >= 0:
                    fw_download = 1
                elif line.find('False') >= 0:
                    fw_download = 0

            elif line.find('HP Linux Imaging and Printing') >= 0:
                res = re.search('(\\d+\\.\\d+\\.\\d+\\w*)', line)
                if res:
                    resg = res.groups()
                    hplip_version = resg[0]


            if plugin_needed >= 0 and plugin_reason >= 0 and fw_download >= 0:
                break
                continue

        if plugin_needed <= 0 or not hplip_version:
            return True
        if glob.glob('/usr/share/hplip/data/plugin/*%s*plugin*' % hplip_version):
            if hplip_version.startswith('2'):

                try:
                    f = open('/etc/hp/hplip.conf', 'r')
                    for line in f:
                        if line.strip().startswith('plugin') and line.strip().endswith('1'):
                            f.close()
                            return True
                        f.close()

            else:
                return True
        hplip_version.startswith('2')
        text = _('For this printer a proprietary driver plugin from HP is available.\n')
        if plugin_needed == 1:
            text += _('The installation of the plugin is required for your printer to work.\n\n')
        elif plugin_needed == 2:
            text += _('Installing the plugin is optional, it completes or enhances the functionality\nof your printer. Without plugin at least basic operations work.\n\n')

        if plugin_reason > 0:
            text += _('The plugin provides the following features:\n')
            if plugin_reason & 1 != 0:
                text += _(' - Printing support\n')

            if plugin_reason & 2 != 0:
                text += _(' - Faster printing\n')

            if plugin_reason & 4 != 0:
                text += _(' - Better printout quality\n')

            if plugin_reason & 8 != 0:
                text += _(' - Extra printing features\n')

            if plugin_reason & 64 != 0:
                text += _(' - Scanning support\n')

            if plugin_reason & 128 != 0:
                text += _(' - Faster scanning\n')

            if plugin_reason & 256 != 0:
                text += _(' - Better scanning image quality\n')

            if plugin_reason & 2048 != 0:
                text += _(' - Faxing support\n')

            if plugin_reason & 4096 != 0:
                text += _(' - Extra fax features\n')

            if plugin_reason & 16384 != 0:
                text += _(' - Better Input/Output support\n')

            if plugin_reason & 32768 != 0:
                text += _(' - Extra user interface features\n')

            if plugin_reason & 65536 != 0:
                text += _(' - Other extra features\n')

            text += '\n'

        text += 'Do you want to download and install the plugin now?\n'
        if plugin_needed == 1:
            text += '\nNOTE: The plugin is required for your printer. If you do not install it, your\nprinter will not work.'
            buttons = (_('Install plugin'), 1, _('Do not set up printer'), 2, _('Set up without plugin'), 3)
        else:
            buttons = (_('Yes'), 1, _('No'), 3)
        dialog = gtk.Dialog(self.device.info, self.NewPrinterWindow, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, buttons)
        label = gtk.Label(text)
        dialog.vbox.pack_start(label, True, True, 0)
        label.show()
        button_clicked = dialog.run()
        dialog.destroy()
        if button_clicked == 1:
            cmds = ("if python -c 'import PyQt4.QtGui' 2>/dev/null; then gksu -- hp-plugin -u; else exit 255; fi", "gksu -- xterm -T 'HPLIP Plugin Installation' -sb -rightbar -e hp-plugin -i")

            try:
                install_result = -1
                for cmd in cmds:
                    p = subprocess.Popen(cmd, shell = True, stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
                    (stdout, stderr) = p.communicate()
                    while p.returncode == None:
                        while gtk.events_pending():
                            gtk.main_iteration()
                        time.sleep(0.1)
                        p.poll()
                    install_result = p.returncode
                    if install_result != 255:
                        break
                        continue

                if install_result == 0:
                    return True
                return False
            except OSError:
                e = None
                debugprint('Execution of hp-plugin failed: %s' % e)
                return False


        None<EXCEPTION MATCH>OSError
        if button_clicked == 2:
            return False
        if button_clicked == 3:
            return True
        return False


    def get_hpfax_device_id(self, faxuri):
        os.environ['URI'] = faxuri
        cmd = 'LC_ALL=C DISPLAY= hp-info -d"${URI}"'
        debugprint(faxuri + ': ' + cmd)

        try:
            p = subprocess.Popen(cmd, shell = True, stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
            (stdout, stderr) = p.communicate()
        except:
            return None

        faxtype = -1
        for line in stdout.split('\n'):
            if line.find('fax-type') == -1:
                continue

            res = re.search('(\\d+)', line)
            if res:
                resg = res.groups()
                faxtype = resg[0]

            if faxtype >= 0:
                break
                continue

        if faxtype <= 0:
            return None
        if faxtype == 4:
            return 'MFG:HP;MDL:Fax 2;DES:HP Fax 2;'
        return 'MFG:HP;MDL:Fax;DES:HP Fax;'


    def get_hplip_uri_for_network_printer(self, host, mode):
        os.environ['HOST'] = host
        if mode == 'print':
            mod = '-c'
        elif mode == 'fax':
            mod = '-f'
        else:
            mod = '-c'
        cmd = 'hp-makeuri ' + mod + ' "${HOST}"'
        debugprint(host + ': ' + cmd)
        uri = None

        try:
            p = subprocess.Popen(cmd, shell = True, stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
            (stdout, stderr) = p.communicate()
        except:
            return None

        uri = stdout.strip()
        return uri


    def getNetworkPrinterMakeModel(self, host = None, device = None):
        '''
        Try to determine the make and model for the currently selected
        network printer, and store this in the data structure for the
        printer.
        Returns (hostname or None, uri or None).
        '''
        uri = None
        if device == None:
            device = self.device

        if host == None:
            s = device.uri.find('://')
            if s != -1:
                s += 3
                e = device.uri[s:].find(':')
                if e == -1:
                    e = device.uri[s:].find('/')

                if e == -1:
                    e = device.uri[s:].find('?')

                if e == -1:
                    e = len(device.uri)

                host = device.uri[s:s + e]


        if host:
            os.environ['HOST'] = host
            cmd = '/usr/lib/cups/backend/snmp "${HOST}"'
            debugprint(host + ': ' + cmd)
            stdout = None

            try:
                p = subprocess.Popen(cmd, shell = True, stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
                (stdout, stderr) = p.communicate()
            except:
                pass

            if stdout != None:
                uri = re.sub('^\\s*\\S+\\s+', '', stdout)
                uri = re.sub('\\s.*$', '', uri)
                mm = re.sub('^\\s*\\S+\\s+\\S+\\s+"', '', stdout)
                mm = re.sub('"\\s+.*$', '', mm)
                if mm and mm != '':
                    device.make_and_model = mm



        make_and_model = None
        if len(device.make_and_model) > 7:
            make_and_model = device.make_and_model
        elif len(device.info) > 7:
            make_and_model = device.info
            make_and_model = re.sub('\\s*(\\(|\\d+\\.\\d+\\.\\d+\\.\\d+).*$', '', make_and_model)

        if make_and_model and not (device.id):
            mk = None
            md = None
            (mk, md) = cupshelpers.ppds.ppdMakeModelSplit(make_and_model)
            device.id = 'MFG:' + mk + ';MDL:' + md + ';DES:' + mk + ' ' + md + ';'
            device.id_dict = cupshelpers.parseDeviceID(device.id)

        return (host, uri)


    def fillDeviceTab(self, current_uri = None):

        try:
            devices = self.fetchDevices()
        except cups.IPPError:
            (e, msg) = None
            self.show_IPP_Error(e, msg)
            devices = { }
        except:
            nonfatalException()
            devices = { }

        if current_uri:
            if devices.has_key(current_uri):
                current = devices.pop(current_uri)
                current.info += _(' (Current)')
            elif devices.has_key(current_uri.replace(':9100', '')):
                current_uri = current_uri.replace(':9100', '')
                current = devices.pop(current_uri)
                current.info += _(' (Current)')
            else:
                current = cupshelpers.Device(current_uri)
                current.info = 'Current device'

        devices = devices.values()
        for device in devices:
            if device.type == 'socket':
                device.uri = device.uri.replace(':9100', '')
                continue


        def replace_generic(device):
            if device.uri == 'hp:/no_device_found':
                device.uri = 'hp'
            elif device.uri == 'hpfax:/no_device_found':
                device.uri = 'hpfax'

            return device

        devices = map(replace_generic, devices)
        for each in devices:
            if each.type == 'hp':
                if each.uri != 'hp':
                    hp = cupshelpers.Device('hp', **{
                        'device-class': 'network',
                        'device-info': _('HP Printer (HPLIP)') })
                    devices.append(hp)
                    break
                else:
                    each.device_class = 'network'
            each.uri != 'hp'

        for i in range(len(devices) - 1):
            for j in range(i + 1, len(devices)):
                device1 = devices[i]
                device2 = devices[j]
                if device1.uri == 'delete' or device2.uri == 'delete':
                    continue

                if device1.uri == device2.uri:
                    if not device1.id:
                        device1.uri = 'delete'
                    elif not device2.id:
                        device2.uri = 'delete'
                    elif len(device1.id) < len(device2.id):
                        device1.uri = 'delete'
                    else:
                        device2.uri = 'delete'
                device1.id


        devices = filter((lambda x: x.uri not in ('hpfax', 'hal', 'beh', 'scsi', 'http', 'delete')), devices)
        self.devices = []
        for device in devices:
            physicaldevice = PhysicalDevice(device)

            try:
                i = self.devices.index(physicaldevice)
                self.devices[i].add_device(device)
            continue
            except ValueError:
                self.devices.append(physicaldevice)
                continue



        self.devices.sort()
        other = cupshelpers.Device('', **{
            'device-info': _('Other') })
        self.devices.append(PhysicalDevice(other))
        device_select_index = 0
        if current_uri:
            current_device = PhysicalDevice(current)

            try:
                i = self.devices.index(current_device)
                self.devices[i].add_device(current)
                device_select_index = i
                devs = self.devices[i].get_devices()
            except ValueError:
                None<EXCEPTION MATCH>ValueError
                None<EXCEPTION MATCH>ValueError
                self.devices.insert(0, current_device)
            except:
                None<EXCEPTION MATCH>ValueError<EXCEPTION MATCH>ValueError


        None<EXCEPTION MATCH>ValueError
        model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT, gobject.TYPE_BOOLEAN)
        network_iter = model.append(None, row = [
            _('Network Printer'),
            None,
            False])
        network_dict = {
            'device-class': 'network',
            'device-info': _('Find Network Printer') }
        network = cupshelpers.Device('network', **network_dict)
        find_nw_iter = model.append(network_iter, row = [
            network_dict['device-info'],
            PhysicalDevice(network),
            False])
        model.insert_after(network_iter, find_nw_iter, row = [
            '',
            None,
            True])
        self.devices_find_nw_iter = find_nw_iter
        self.tvNPDevices.set_model(model)
        i = 0
        device_select_path = None
        for device in self.devices:
            devs = device.get_devices()
            network = devs[0].device_class == 'network'
            row = [
                device.get_info(),
                device,
                False]
            if network:
                if devs[0].uri != devs[0].type:
                    iter = model.insert_before(network_iter, find_nw_iter, row = row)
                    if device_select_index == i:
                        network_path = model.get_path(network_iter)
                        self.tvNPDevices.expand_row(network_path, False)

                else:
                    iter = model.append(network_iter, row = row)
            else:
                iter = model.insert_before(None, network_iter, row = row)
            if device_select_index == i:
                device_select_path = model.get_path(iter)
                self.tvNPDevices.scroll_to_cell(device_select_path, row_align = 0.5)
                column = self.tvNPDevices.get_column(0)
                self.tvNPDevices.set_cursor(device_select_path, column)

            i += 1

        connection_select_path = 0
        if current_uri:
            model = self.tvNPDeviceURIs.get_model()
            iter = model.get_iter_first()
            i = 0
            while iter:
                dev = model.get_value(iter, 1)
                if current_uri == dev.uri:
                    connection_select_path = i
                    break

                iter = model.iter_next(iter)
                i += 1

        column = self.tvNPDeviceURIs.get_column(0)
        self.tvNPDeviceURIs.set_cursor(connection_select_path, column)


    def on_entNPTDevice_changed(self, entry):
        self.setNPButtons()


    def browse_smb_hosts(self):
        '''Initialise the SMB tree store.'''
        store = self.smb_store
        store.clear()
        self.busy(self.SMBBrowseDialog)

        class X:
            pass

        dummy = X()
        dummy.smbc_type = pysmb.smbc.PRINTER_SHARE
        dummy.name = _('Scanning...')
        dummy.comment = ''
        store.append(None, [
            dummy])
        while gtk.events_pending():
            gtk.main_iteration()
        debug = 0
        if get_debugging():
            debug = 10

        smbc_auth = pysmb.AuthContext(self.SMBBrowseDialog)
        ctx = pysmb.smbc.Context(debug = debug, auth_fn = smbc_auth.callback)
        entries = None

        try:
            while smbc_auth.perform_authentication() > 0:

                try:
                    entries = ctx.opendir('smb://').getdents()
                continue
                except Exception:
                    e = None
                    smbc_auth.failed(e)
                    continue


                None<EXCEPTION MATCH>Exception
        except RuntimeError:
            (e, s) = None
            if e != errno.ENOENT:
                debugprint('Runtime error: %s' % repr((e, s)))

        except:
            e != errno.ENOENT
            nonfatalException()

        store.clear()
        if entries:
            for entry in entries:
                if entry.smbc_type in [
                    pysmb.smbc.WORKGROUP,
                    pysmb.smbc.SERVER]:
                    iter = store.append(None, [
                        entry])
                    i = store.append(iter)
                    continue


        specified_uri = SMBURI(uri = self.entSMBURI.get_text())
        (group, host, share, user, password) = specified_uri.separate()
        if len(host) > 0:

            class FakeEntry:
                pass

            toplevel = FakeEntry()
            toplevel.smbc_type = pysmb.smbc.SERVER
            toplevel.name = host
            toplevel.comment = ''
            iter = store.append(None, [
                toplevel])
            i = store.append(iter)
            path = store.get_path(iter)
            self.tvSMBBrowser.expand_row(path, 0)

        self.ready(self.SMBBrowseDialog)
        if store.get_iter_first() == None:
            self.SMBBrowseDialog.hide()
            show_info_dialog(_('No Print Shares'), _('There were no print shares found.  Please check that the Samba service is marked as trusted in your firewall configuration.') + '\n\n' + TEXT_start_firewall_tool, parent = self.NewPrinterWindow)



    def smb_select_function(self, path):
        """Don't allow this path to be selected unless it is a leaf."""
        iter = self.smb_store.get_iter(path)
        return not self.smb_store.iter_has_child(iter)


    def smbbrowser_cell_share(self, column, cell, model, iter):
        entry = model.get_value(iter, 0)
        share = ''
        if entry != None:
            share = entry.name

        cell.set_property('text', share)


    def smbbrowser_cell_comment(self, column, cell, model, iter):
        entry = model.get_value(iter, 0)
        comment = ''
        if entry != None:
            comment = entry.comment

        cell.set_property('text', comment)


    def on_tvSMBBrowser_row_activated(self, view, path, column):
        '''Handle double-clicks in the SMB tree view.'''
        store = self.smb_store
        iter = store.get_iter(path)
        entry = store.get_value(iter, 0)
        if entry and entry.smbc_type == pysmb.smbc.PRINTER_SHARE:
            self.btnSMBBrowseOk.clicked()
            return None
        if view.row_expanded(path):
            view.collapse_row(path)
        else:
            self.on_tvSMBBrowser_row_expanded(view, iter, path)


    def on_tvSMBBrowser_row_expanded(self, view, iter, path):
        '''Handler for expanding a row in the SMB tree view.'''
        model = view.get_model()
        entry = model.get_value(iter, 0)
        if entry == None:
            return None
        if entry.smbc_type == pysmb.smbc.WORKGROUP:

            try:
                if self.expanding_row:
                    return None
            except:
                entry == None
                self.expanding_row = 1

            self.busy(self.SMBBrowseDialog)
            uri = 'smb://%s/' % entry.name
            debug = 0
            if get_debugging():
                debug = 10

            smbc_auth = pysmb.AuthContext(self.SMBBrowseDialog)
            ctx = pysmb.smbc.Context(debug = debug, auth_fn = smbc_auth.callback)
            entries = []

            try:
                while smbc_auth.perform_authentication() > 0:

                    try:
                        entries = ctx.opendir(uri).getdents()
                    continue
                    except Exception:
                        e = None
                        smbc_auth.failed(e)
                        continue


                    None<EXCEPTION MATCH>Exception
            except RuntimeError:
                (e, s) = None
                if e != errno.ENOENT:
                    debugprint('Runtime error: %s' % repr((e, s)))

            except:
                e != errno.ENOENT
                nonfatalException()

            while model.iter_has_child(iter):
                i = model.iter_nth_child(iter, 0)
                model.remove(i)
            for entry in entries:
                if entry.smbc_type in [
                    pysmb.smbc.SERVER,
                    pysmb.smbc.PRINTER_SHARE]:
                    i = model.append(iter, [
                        entry])

                if entry.smbc_type == pysmb.smbc.SERVER:
                    n = model.append(i)
                    continue

            view.expand_row(path, 0)
            del self.expanding_row
            self.ready(self.SMBBrowseDialog)
        elif entry.smbc_type == pysmb.smbc.SERVER:

            try:
                if self.expanding_row:
                    return None
            except:
                entry == None
                self.expanding_row = 1

            self.busy(self.SMBBrowseDialog)
            uri = 'smb://%s/' % entry.name
            debug = 0
            if get_debugging():
                debug = 10

            smbc_auth = pysmb.AuthContext(self.SMBBrowseDialog)
            ctx = pysmb.smbc.Context(debug = debug, auth_fn = smbc_auth.callback)
            shares = []

            try:
                while smbc_auth.perform_authentication() > 0:

                    try:
                        shares = ctx.opendir(uri).getdents()
                    continue
                    except Exception:
                        e = None
                        smbc_auth.failed(e)
                        continue


                    None<EXCEPTION MATCH>Exception
            except RuntimeError:
                (e, s) = None
                if e != errno.EACCES and e != errno.EPERM:
                    debugprint('Runtime error: %s' % repr((e, s)))

            except:
                e != errno.EPERM
                nonfatalException()

            while model.iter_has_child(iter):
                i = model.iter_nth_child(iter, 0)
                model.remove(i)
            for share in shares:
                if share.smbc_type == pysmb.smbc.PRINTER_SHARE:
                    i = model.append(iter, [
                        share])
                    debugprint(repr(share))
                    continue

            view.expand_row(path, 0)
            del self.expanding_row
            self.ready(self.SMBBrowseDialog)



    def on_entSMBURI_changed(self, ent):
        uri = ent.get_text()
        (group, host, share, user, password) = SMBURI(uri = uri).separate()
        if user:
            self.entSMBUsername.set_text(user)

        if password:
            self.entSMBPassword.set_text(password)

        if user or password:
            uri = SMBURI(group = group, host = host, share = share).get_uri()
            ent.set_text(uri)
            self.rbtnSMBAuthSet.set_active(True)
        elif self.entSMBUsername.get_text() == '':
            self.rbtnSMBAuthPrompt.set_active(True)

        self.btnSMBVerify.set_sensitive(bool(uri))
        self.setNPButtons()


    def on_tvSMBBrowser_cursor_changed(self, widget):
        (store, iter) = self.tvSMBBrowser.get_selection().get_selected()
        is_share = False
        if iter:
            entry = store.get_value(iter, 0)
            if entry:
                is_share = entry.smbc_type == pysmb.smbc.PRINTER_SHARE


        if iter != None:
            pass
        self.btnSMBBrowseOk.set_sensitive(is_share)


    def on_btnSMBBrowse_clicked(self, button):
        self.btnSMBBrowseOk.set_sensitive(False)
        self.SMBBrowseDialog.show()
        self.browse_smb_hosts()


    def on_btnSMBBrowseOk_clicked(self, button):
        (store, iter) = self.tvSMBBrowser.get_selection().get_selected()
        is_share = False
        if iter:
            entry = store.get_value(iter, 0)
            if entry:
                is_share = entry.smbc_type == pysmb.smbc.PRINTER_SHARE


        if not iter or not is_share:
            self.SMBBrowseDialog.hide()
            return None
        parent_iter = store.iter_parent(iter)
        domain_iter = store.iter_parent(parent_iter)
        share = store.get_value(iter, 0)
        host = store.get_value(parent_iter, 0)
        if domain_iter:
            group = store.get_value(domain_iter, 0).name
        else:
            group = ''
        uri = SMBURI(group = group, host = host.name, share = share.name).get_uri()
        self.entSMBUsername.set_text('')
        self.entSMBPassword.set_text('')
        self.entSMBURI.set_text(uri)
        self.SMBBrowseDialog.hide()


    def on_btnSMBBrowseCancel_clicked(self, widget, *args):
        self.SMBBrowseDialog.hide()


    def on_btnSMBBrowseRefresh_clicked(self, button):
        self.browse_smb_hosts()


    def on_rbtnSMBAuthSet_toggled(self, widget):
        self.tblSMBAuth.set_sensitive(widget.get_active())


    def on_btnSMBVerify_clicked(self, button):
        uri = self.entSMBURI.get_text()
        (group, host, share, u, p) = SMBURI(uri = uri).separate()
        user = ''
        passwd = ''
        reason = None
        auth_set = self.rbtnSMBAuthSet.get_active()
        if auth_set:
            user = self.entSMBUsername.get_text()
            passwd = self.entSMBPassword.get_text()

        accessible = False
        canceled = False
        self.busy()

        try:
            debug = 0
            if get_debugging():
                debug = 10

            if auth_set:

                def do_auth(svr, shr, wg, un, pw):
                    return (group, user, passwd)

                ctx = pysmb.smbc.Context(debug = debug, auth_fn = do_auth)
                f = ctx.open('smb://%s/%s' % (host, share), os.O_RDWR, 511)
                accessible = True
            else:
                smbc_auth = pysmb.AuthContext(self.NewPrinterWindow, workgroup = group, user = user, passwd = passwd)
                ctx = pysmb.smbc.Context(debug = debug, auth_fn = smbc_auth.callback)
                while smbc_auth.perform_authentication() > 0:

                    try:
                        f = ctx.open('smb://%s/%s' % (host, share), os.O_RDWR, 511)
                        accessible = True
                    continue
                    except Exception:
                        e = None
                        smbc_auth.failed(e)
                        continue


                    None<EXCEPTION MATCH>Exception
                if not accessible:
                    canceled = True
        except RuntimeError:
            (e, s) = None
            debugprint('Error accessing share: %s' % repr((e, s)))
            reason = s
        except:
            nonfatalException()


        self.ready()
        if accessible:
            show_info_dialog(_('Print Share Verified'), _('This print share is accessible.'), parent = self.NewPrinterWindow)
            return None


    def update_IPP_URI_label(self):
        hostname = self.entNPTIPPHostname.get_text()
        queue = self.entNPTIPPQueuename.get_text()
        if len(hostname) > 0:
            pass
        valid = queue != '/printers/'
        if valid:
            uri = 'ipp://%s%s' % (hostname, queue)
            self.lblIPPURI.set_text(uri)
            self.lblIPPURI.show()
            self.entNPTIPPQueuename.show()
        else:
            self.lblIPPURI.hide()
        self.btnIPPVerify.set_sensitive(valid)
        self.setNPButtons()


    def on_entNPTIPPHostname_changed(self, ent):
        valid = len(ent.get_text()) > 0
        self.btnIPPFindQueue.set_sensitive(valid)
        self.update_IPP_URI_label()


    def on_entNPTIPPQueuename_changed(self, ent):
        self.update_IPP_URI_label()


    def on_btnIPPFindQueue_clicked(self, button):
        self.btnIPPBrowseOk.set_sensitive(False)
        self.IPPBrowseDialog.show()
        self.browse_ipp_queues()


    def on_btnIPPVerify_clicked(self, button):
        uri = self.lblIPPURI.get_text()
        match = re.match('(ipp|https?)://([^/]+)(.*)/([^/]*)', uri)
        verified = False
        if match:
            oldserver = cups.getServer()

            try:
                c = cups.Connection(host = match.group(2))
                attributes = c.getPrinterAttributes(uri = uri)
                verified = True
            except cups.IPPError:
                (e, msg) = None
                debugprint('Failed to get attributes: %s (%d)' % (msg, e))
            except:
                nonfatalException()

            cups.setServer(oldserver)
        else:
            debugprint(uri)
        if verified:
            show_info_dialog(_('Print Share Verified'), _('This print share is accessible.'), parent = self.NewPrinterWindow)
        else:
            show_error_dialog(_('Inaccessible'), _('This print share is not accessible.'), self.NewPrinterWindow)


    def browse_ipp_queues(self):
        if not self.ipp_lock.acquire(0):
            return None
        thread.start_new_thread(self.browse_ipp_queues_thread, ())


    def browse_ipp_queues_thread(self):
        host = None
        gtk.gdk.threads_enter()

        try:
            store = self.ipp_store
            store.clear()
            store.append(None, (_('Scanning...'), '', None))

            try:
                self.busy(self.IPPBrowseDialog)
            except:
                nonfatalException()

            host = self.entNPTIPPHostname.get_text()
        except:
            nonfatalException()

        gtk.gdk.threads_leave()
        oldserver = cups.getServer()
        printers = classes = { }
        failed = False
        port = 631
        if host != None:
            (host, port) = urllib.splitnport(host, defport = port)


        try:
            c = cups.Connection(host = host, port = port)
            printers = c.getPrinters()
            del c
        except cups.IPPError:
            (e, m) = None
            debugprint('IPP browser: %s' % m)
            failed = True
        except:
            nonfatalException()
            failed = True

        cups.setServer(oldserver)
        gtk.gdk.threads_enter()

        try:
            store.clear()
            for printer, dict in printers.iteritems():
                iter = store.append(None)
                store.set_value(iter, 0, printer)
                store.set_value(iter, 1, dict.get('printer-location', ''))
                store.set_value(iter, 2, dict)

            if len(printers) + len(classes) == 0:
                if failed:
                    title = _('Not possible')
                    text = _("It is not possible to obtain a list of queues from '%s'.") % host + '\n\n' + _('Obtaining a list of queues is a CUPS extension to IPP.  Network printers do not support it.')
                else:
                    title = _('No queues')
                    text = _('There are no queues available.')
                self.IPPBrowseDialog.hide()
                show_error_dialog(title, text, self.NewPrinterWindow)


            try:
                self.ready(self.IPPBrowseDialog)
            except:
                nonfatalException()

            self.ipp_lock.release()
        except:
            nonfatalException()

        gtk.gdk.threads_leave()


    def on_tvIPPBrowser_cursor_changed(self, widget):
        self.btnIPPBrowseOk.set_sensitive(True)


    def on_btnIPPBrowseOk_clicked(self, button):
        (store, iter) = self.tvIPPBrowser.get_selection().get_selected()
        self.IPPBrowseDialog.hide()
        queue = store.get_value(iter, 0)
        dict = store.get_value(iter, 2)
        self.entNPTIPPQueuename.set_text(queue)
        self.entNPTIPPQueuename.show()
        uri = dict.get('printer-uri-supported', 'ipp')
        match = re.match('(ipp|https?)://([^/]+)(.*)', uri)
        if match:
            self.entNPTIPPHostname.set_text(match.group(2))
            self.entNPTIPPQueuename.set_text(match.group(3))

        self.lblIPPURI.set_text(uri)
        self.lblIPPURI.show()
        self.setNPButtons()


    def on_btnIPPBrowseCancel_clicked(self, widget, *args):
        self.IPPBrowseDialog.hide()


    def on_btnIPPBrowseRefresh_clicked(self, button):
        self.browse_ipp_queues()


    def on_expNPDeviceURIs_expanded(self, widget, UNUSED):
        parent = widget.get_parent()
        (expand, fill, padding, pack_type) = parent.query_child_packing(widget)
        expand = widget.get_expanded()
        parent.set_child_packing(widget, expand, fill, padding, pack_type)


    def device_row_separator_fn(self, model, iter):
        return model.get_value(iter, 2)


    def device_row_activated(self, view, path, column):
        if view.row_expanded(path):
            view.collapse_row(path)
        else:
            view.expand_row(path, False)


    def device_select_function(self, path):
        '''
        Allow this path to be selected as long as there
        is a device associated with it.
        '''
        model = self.tvNPDevices.get_model()
        iter = model.get_iter(path)
        return model.get_value(iter, 1) != None


    def on_tvNPDevices_cursor_changed(self, widget):
        (path, column) = widget.get_cursor()
        if path == None:
            return None
        model = widget.get_model()
        iter = model.get_iter(path)
        physicaldevice = model.get_value(iter, 1)
        if physicaldevice == None:
            return None
        for device in physicaldevice.get_devices():
            if device.type == 'parallel':
                device.menuentry = _('Parallel Port')
                continue
            physicaldevice == None
            if device.type == 'serial':
                device.menuentry = _('Serial Port')
                continue
            path == None
            if device.type == 'usb':
                device.menuentry = _('USB')
                continue
            if device.type == 'hp':
                device.menuentry = _('HP Linux Imaging and Printing (HPLIP)')
                continue
            if device.type == 'hpfax':
                device.menuentry = _('Fax') + ' - ' + _('HP Linux Imaging and Printing (HPLIP)')
                continue
            if device.type == 'hal':
                device.menuentry = _('Hardware Abstraction Layer (HAL)')
                continue
            if device.type == 'socket':
                device.menuentry = _('AppSocket/HP JetDirect')
                continue
            if device.type == 'lpd':
                device.menuentry = _('LPD/LPR')
                continue
            if device.type == 'smb':
                device.menuentry = _('Windows Printer via SAMBA')
                continue
            if device.type == 'ipp':
                device.menuentry = _('IPP')
                continue
            if device.type == 'http':
                device.menuentry = _('HTTP')
                continue
            device.menuentry = device.uri

        model = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
        self.tvNPDeviceURIs.set_model(model)
        if physicaldevice.get_data('checked-hplip') != True:
            hp_drivable = False
            is_network = False
            device_dict = {
                'device-class': 'network' }
            for device in physicaldevice.get_devices():
                if device.type == 'hp':
                    hp_drivable = True
                    break
                    continue
                if device.type in ('socket', 'lpd', 'ipp'):
                    (scheme, rest) = urllib.splittype(device.uri)
                    (hostport, rest) = urllib.splithost(rest)
                    if hostport != None:
                        (host, port) = urllib.splitport(hostport)
                        is_network = True
                        self.getNetworkPrinterMakeModel(host = host, device = device)
                        device_dict['device-info'] = device.info
                        device_dict['device-make-and-model'] = device.make_and_model
                        device_dict['device-id'] = device.id

                hostport != None

            if not hp_drivable and is_network:
                hplipuri = self.get_hplip_uri_for_network_printer(host, 'print')
                if hplipuri:
                    dev = cupshelpers.Device(hplipuri, **device_dict)
                    dev.menuentry = 'HP Linux Imaging and Printing (HPLIP)'
                    physicaldevice.add_device(dev)
                    faxuri = self.get_hplip_uri_for_network_printer(host, 'fax')
                    if faxuri:
                        faxdevid = self.get_hpfax_device_id(faxuri)
                        device_dict['device-id'] = faxdevid
                        device_dict['device-info'] = _('Fax')
                        faxdev = cupshelpers.Device(faxuri, **device_dict)
                        faxdev.menuentry = _('Fax') + ' - ' + 'HP Linux Imaging and Printing (HPLIP)'
                        physicaldevice.add_device(faxdev)


                physicaldevice.set_data('checked-hplip', True)


        n = 0
        for device in physicaldevice.get_devices():
            model.append((device.menuentry, device))
            n += 1

        column = self.tvNPDeviceURIs.get_column(0)
        self.tvNPDeviceURIs.set_cursor(0, column)
        if n > 1:
            self.expNPDeviceURIs.show_all()
        else:
            self.expNPDeviceURIs.hide()


    def on_tvNPDeviceURIs_cursor_changed(self, widget):
        (model, iter) = widget.get_selection().get_selected()
        device = model.get_value(iter, 1)
        self.device = device
        self.lblNPDeviceDescription.set_text('')
        page = self.new_printer_device_tabs.get(device.type, 1)
        if device.type == 'hp' and device.uri != 'hp':
            page = 0

        self.ntbkNPType.set_current_page(page)
        location = ''
        type = device.type
        url = device.uri.split(':', 1)[-1]
        if page == 0:
            if device.type == 'parallel':
                text = _('A printer connected to the parallel port.')
            elif device.type == 'usb':
                text = _('A printer connected to a USB port.')
            elif device.type == 'hp':
                text = _('HPLIP software driving a printer, or the printer function of a multi-function device.')
            elif device.type == 'hpfax':
                text = _('HPLIP software driving a fax machine, or the fax function of a multi-function device.')
            elif device.type == 'hal':
                text = _('Local printer detected by the Hardware Abstraction Layer (HAL).')
            else:
                text = device.uri
            self.lblNPDeviceDescription.set_text(text)
        elif device.type == 'socket':
            (scheme, rest) = urllib.splittype(device.uri)
            host = ''
            port = 9100
            if scheme == 'socket':
                (hostport, rest) = urllib.splithost(rest)
                (host, port) = urllib.splitnport(hostport, defport = port)
                debugprint('socket: host is %s, port is %s' % (host, repr(port)))
                location = host

            self.entNPTDirectJetHostname.set_text(host)
            self.entNPTDirectJetPort.set_text(str(port))
        elif device.type == 'serial':
            if not device.is_class:
                options = device.uri.split('?')[1]
                options = options.split('+')
                option_dict = { }
                for option in options:
                    (name, value) = option.split('=')
                    option_dict[name] = value

                for widget, name, optionvalues in ((self.cmbNPTSerialBaud, 'baud', None), (self.cmbNPTSerialBits, 'bits', None), (self.cmbNPTSerialParity, 'parity', [
                    'none',
                    'odd',
                    'even']), (self.cmbNPTSerialFlow, 'flow', [
                    'none',
                    'soft',
                    'hard',
                    'hard'])):
                    if option_dict.has_key(name):
                        if optionvalues is None:
                            model = widget.get_model()
                            iter = model.get_iter_first()
                            nr = 0
                            while iter:
                                value = model.get(iter, 0)[0]
                                if value == option_dict[name]:
                                    widget.set_active(nr)
                                    break

                                iter = model.iter_next(iter)
                                nr += 1
                        else:
                            nr = optionvalues.index(option_dict[name])
                            widget.set_active(nr + 1)
                    optionvalues is None
                    widget.set_active(0)


        elif device.type in ('ipp', 'http'):
            if device.uri.startswith('ipp:') or device.uri.startswith('http:'):
                match = re.match('(ipp|https?)://([^/]+)(.*)', device.uri)
                if match:
                    server = match.group(2)
                    printer = match.group(3)
                else:
                    server = ''
                    printer = ''
                self.entNPTIPPHostname.set_text(server)
                self.entNPTIPPQueuename.set_text(printer)
                self.lblIPPURI.set_text(device.uri)
                self.lblIPPURI.show()
                self.entNPTIPPQueuename.show()
                location = server
            else:
                self.entNPTIPPHostname.set_text('')
                self.entNPTIPPQueuename.set_text('/printers/')
                self.entNPTIPPQueuename.show()
                self.lblIPPURI.hide()
        elif device.type == 'lpd':
            if device.uri.startswith('lpd'):
                host = device.uri[6:]
                i = host.find('/')
                if i != -1:
                    printer = host[i + 1:]
                    host = host[:i]
                else:
                    printer = ''
                self.cmbentNPTLpdHost.child.set_text(host)
                self.cmbentNPTLpdQueue.child.set_text(printer)
                location = host

        elif device.uri == 'lpd':
            pass
        elif device.uri == 'smb':
            self.entSMBURI.set_text('')
            self.btnSMBVerify.set_sensitive(False)
        elif device.type == 'smb':
            self.entSMBUsername.set_text('')
            self.entSMBPassword.set_text('')
            self.entSMBURI.set_text(device.uri[6:])
            self.btnSMBVerify.set_sensitive(True)
        elif device.uri == 'hp':
            self.lblHPURI.set_text('')
        else:
            self.entNPTDevice.set_text(device.uri)

        try:
            if len(location) == 0 and self.device.device_class == 'direct':
                u = os.uname()
                location = u[1]

            self.entNPLocation.set_text(location)
        except:
            nonfatalException()

        self.setNPButtons()


    def on_btnNPTLpdProbe_clicked(self, button):
        hostname = self.cmbentNPTLpdHost.get_active_text()
        server = probe_printer.LpdServer(hostname)
        printers = server.probe()
        model = self.cmbentNPTLpdQueue.get_model()
        model.clear()
        for printer in printers:
            self.cmbentNPTLpdQueue.append_text(printer)

        if printers:
            self.cmbentNPTLpdQueue.set_active(0)



    def on_entNPTHPHostname_changed(self, ent):
        self.lblHPURI.set_text('')
        s = ent.get_text()
        self.btnHPFindQueue.set_sensitive(len(s) > 0)
        self.setNPButtons()


    def on_btnHPFindQueue_clicked(self, button):
        host = self.entNPTHPHostname.get_text()
        hplipuri = self.get_hplip_uri_for_network_printer(host, 'print')
        if hplipuri == None or hplipuri == '':
            show_error_dialog(_('No Print Shares'), _('HPLIP cannot find the device.'), self.NewPrinterWindow)
            self.entNPTHPHostname.grab_focus()
            return None
        self.lblHPURI.set_text(hplipuri)
        s = hplipuri.find('/usb/')
        if s == -1:
            s = hplipuri.find('/par/')

        if s == -1:
            s = hplipuri.find('/net/')

        if s != -1:
            s += 5
            e = hplipuri[s:].find('?')
            if e == -1:
                e = len(hplipuri)

            mdl = hplipuri[s:s + e].replace('_', ' ')
            if mdl.startswith('hp ') or mdl.startswith('HP '):
                mdl = mdl[3:]
                self.device.make_and_model = 'HP ' + mdl
                id = 'MFG:HP;MDL:%s;DES:HP %s;' % (mdl, mdl)
                self.device.id = id
                self.device.id_dict = cupshelpers.parseDeviceID(id)




    def on_entNPTNetworkHostname_changed(self, ent):
        s = ent.get_text()
        self.btnNetworkFind.set_sensitive(len(s) > 0)
        self.setNPButtons()


    def on_btnNetworkFind_clicked(self, button):
        host = self.entNPTNetworkHostname.get_text()
        uri = self.get_hplip_uri_for_network_printer(host, 'print')
        device_dict = {
            'device-class': 'network' }
        new_device = cupshelpers.Device('', **device_dict)
        if uri:
            new_device = cupshelpers.Device(uri, **device_dict)

        (host, uri) = self.getNetworkPrinterMakeModel(host = host, device = new_device)
        if uri:
            new_device.uri = uri

        debugprint('New device: %s' % new_device)
        if not new_device.uri:
            show_error_dialog(_('Not Found'), _('No printer was found at that address.'), parent = self.NewPrinterWindow)
        else:
            model = self.tvNPDevices.get_model()
            dev = PhysicalDevice(new_device)
            iter = model.insert_before(None, self.devices_find_nw_iter, row = [
                dev.get_info(),
                dev,
                False])
            path = model.get_path(iter)
            self.tvNPDevices.set_cursor(path)


    def getDeviceURI(self):
        type = self.device.type
        if type == 'socket':
            host = self.entNPTDirectJetHostname.get_text()
            port = self.entNPTDirectJetPort.get_text()
            device = 'socket://' + host
            if host and port:
                device = device + ':' + port

        elif type in ('http', 'ipp'):
            if self.lblIPPURI.get_property('visible'):
                device = self.lblIPPURI.get_text()
            else:
                device = 'ipp'
        elif type == 'lpd':
            host = self.cmbentNPTLpdHost.get_active_text()
            printer = self.cmbentNPTLpdQueue.get_active_text()
            device = 'lpd://' + host
            if printer:
                device = device + '/' + printer

        elif type == 'parallel':
            device = self.device.uri
        elif type == 'scsi':
            device = ''
        elif type == 'serial':
            options = []
            for widget, name, optionvalues in ((self.cmbNPTSerialBaud, 'baud', None), (self.cmbNPTSerialBits, 'bits', None), (self.cmbNPTSerialParity, 'parity', ('none', 'odd', 'even')), (self.cmbNPTSerialFlow, 'flow', ('none', 'soft', 'hard', 'hard'))):
                nr = widget.get_active()
                if nr:
                    if optionvalues is not None:
                        option = optionvalues[nr - 1]
                    else:
                        option = widget.get_active_text()
                    options.append(name + '=' + option)
                    continue

            options = '+'.join(options)
            device = self.device.uri.split('?')[0]
            if options:
                device = device + '?' + options

        elif type == 'smb':
            uri = self.entSMBURI.get_text()
            (group, host, share, u, p) = SMBURI(uri = uri).separate()
            user = ''
            password = ''
            if self.rbtnSMBAuthSet.get_active():
                user = self.entSMBUsername.get_text()
                password = self.entSMBPassword.get_text()

            uri = SMBURI(group = group, host = host, share = share, user = user, password = password).get_uri()
            device = 'smb://' + uri
        elif self.device.uri == 'hp':
            device = self.lblHPURI.get_text()
        elif not self.device.is_class:
            device = self.device.uri
        else:
            device = self.entNPTDevice.get_text()
        return device


    def on_rbtnNPFoomatic_toggled(self, widget):
        rbtn1 = self.rbtnNPFoomatic.get_active()
        rbtn2 = self.rbtnNPPPD.get_active()
        rbtn3 = self.rbtnNPDownloadableDriverSearch.get_active()
        self.tvNPMakes.set_sensitive(rbtn1)
        self.filechooserPPD.set_sensitive(rbtn2)
        if rbtn1:
            page = 0

        if rbtn2:
            page = 1

        if rbtn3:
            page = 2

        self.ntbkPPDSource.set_current_page(page)
        if not rbtn3 and self.openprinting_query_handle:
            self.openprinting.cancelOperation(self.openprinting_query_handle)
            self.openprinting_query_handle = None
            self.btnNPDownloadableDriverSearch_label.set_text(_('Search'))
            model = gtk.ListStore(str, str)
            combobox = self.cmbNPDownloadableDriverFoundPrinters
            combobox.set_model(model)
            combobox.set_sensitive(False)

        for widget in [
            self.entNPDownloadableDriverSearch,
            self.cmbNPDownloadableDriverFoundPrinters]:
            widget.set_sensitive(rbtn3)

        if rbtn3:
            pass
        self.btnNPDownloadableDriverSearch.set_sensitive(self.openprinting_query_handle == None)
        self.setNPButtons()


    def on_filechooserPPD_selection_changed(self, widget):
        self.setNPButtons()


    def on_btnNPDownloadableDriverSearch_clicked(self, widget):
        if self.openprinting_query_handle != None:
            self.openprinting.cancelOperation(self.openprinting_query_handle)
            self.openprinting_query_handle = None

        widget.set_sensitive(False)
        label = self.btnNPDownloadableDriverSearch_label
        label.set_text(_('Searching'))
        searchterm = self.entNPDownloadableDriverSearch.get_text()
        self.openprinting_query_handle = self.openprinting.searchPrinters(searchterm, self.openprinting_printers_found)
        self.cmbNPDownloadableDriverFoundPrinters.set_sensitive(False)


    def openprinting_printers_found(self, status, user_data, printers):
        self.openprinting_query_handle = None
        button = self.btnNPDownloadableDriverSearch
        label = self.btnNPDownloadableDriverSearch_label
        gtk.gdk.threads_enter()

        try:
            label.set_text(_('Search'))
            button.set_sensitive(True)
            if status != 0:
                print printers
                print traceback.extract_tb(printers[2], limit = None)
                gtk.gdk.threads_leave()
                return None
            model = gtk.ListStore(str, str)
            sorted_list = []
            for id, name in printers.iteritems():
                sorted_list.append((id, name))

            sorted_list.sort((lambda x, y: cups.modelSort(x[1], y[1])))
            sought = self.entNPDownloadableDriverSearch.get_text().lower()
            select_index = 0
            for id, name in sorted_list:
                iter = model.append(None)
                model.set_value(iter, 0, name)
                model.set_value(iter, 1, id)
                if name.lower() == sought:
                    select_index = model.get_path(iter)[0]
                    continue
                None if len(printers) != 1 else status != 0

            combobox = self.cmbNPDownloadableDriverFoundPrinters
            combobox.set_model(model)
            combobox.set_active(select_index)
            combobox.set_sensitive(True)
            self.setNPButtons()
        except:
            nonfatalException()

        gtk.gdk.threads_leave()


    def on_cmbNPDownloadableDriverFoundPrinters_changed(self, widget):
        self.setNPButtons()
        if self.openprinting_query_handle != None:
            self.openprinting.cancelOperation(self.openprinting_query_handle)
            self.openprinting_query_handle = None
            self.drivers_lock.release()

        model = widget.get_model()
        iter = widget.get_active_iter()
        if iter:
            id = model.get_value(iter, 1)
        else:
            id = None
        if id == None:
            return None
        debugprint('Query drivers for %s' % id)
        self.drivers_lock.acquire(0)
        extra_options = dict()
        if self.DOWNLOADABLE_ONLYPPD:
            extra_options['onlyppdfiles'] = '1'

        self.openprinting_query_handle = self.openprinting.listDrivers(id, self.openprinting_drivers_found, extra_options = extra_options)


    def openprinting_drivers_found(self, status, user_data, drivers):
        if status != 0:
            print drivers
            print traceback.extract_tb(drivers[2], limit = None)
            return None
        self.openprinting_query_handle = None
        self.downloadable_drivers = drivers
        debugprint('Drivers query completed: %s' % drivers.keys())
        self.drivers_lock.release()


    def fillDownloadableDrivers(self):
        self.lblNPDownloadableDriverSupplier.set_text('')
        self.lblNPDownloadableDriverLicense.set_text('')
        self.lblNPDownloadableDriverDescription.set_text('')
        self.lblNPDownloadableDriverSupportContacts.set_text('')
        self.rbtnNPDownloadLicenseNo.set_active(True)
        self.frmNPDownloadableDriverLicenseTerms.hide()
        drivers = self.downloadable_drivers
        model = gtk.ListStore(str, gobject.TYPE_PYOBJECT)
        recommended_iter = None
        first_iter = None
        for driver in drivers.values():
            iter = model.append(None)
            if first_iter == None:
                first_iter = iter

            model.set_value(iter, 0, driver['name'])
            model.set_value(iter, 1, driver)
            if driver['recommended']:
                recommended_iter = iter
                continue

        if recommended_iter == None:
            recommended_iter = first_iter

        treeview = self.tvNPDownloadableDrivers
        treeview.set_model(model)
        if recommended_iter != None:
            treeview.get_selection().select_iter(recommended_iter)



    def on_rbtnNPDownloadLicense_toggled(self, widget):
        self.setNPButtons()


    def fillMakeList(self):
        makes = self.ppds.getMakes()
        model = self.tvNPMakes.get_model()
        model.clear()
        found = False
        for make in makes:
            iter = model.append((make,))
            if make.lower() == self.auto_make.lower():
                path = model.get_path(iter)
                self.tvNPMakes.set_cursor(path)
                self.tvNPMakes.scroll_to_cell(path, None, True, 0.5, 0.5)
                found = True
                continue

        if not found:
            self.tvNPMakes.set_cursor(0)
            self.tvNPMakes.scroll_to_cell(0, None, True, 0, 0)

        search = ''
        if self.auto_make != None:
            search += self.auto_make
            if self.auto_model != None:
                search += ' ' + self.auto_model


        self.entNPDownloadableDriverSearch.set_text(search)


    def on_tvNPMakes_cursor_changed(self, tvNPMakes):
        (path, column) = tvNPMakes.get_cursor()
        if path != None:
            model = tvNPMakes.get_model()
            iter = model.get_iter(path)
            self.NPMake = model.get(iter, 0)[0]
            self.fillModelList()



    def fillModelList(self):
        models = self.ppds.getModels(self.NPMake)
        model = self.tvNPModels.get_model()
        model.clear()
        selected = False
        for pmodel in models:
            iter = model.append((pmodel,))
            if self.NPMake.lower() == self.auto_make.lower() and pmodel.lower() == self.auto_model.lower():
                path = model.get_path(iter)
                self.tvNPModels.set_cursor(path)
                self.tvNPModels.scroll_to_cell(path, None, True, 0.5, 0.5)
                selected = True
                continue

        if not selected:
            self.tvNPModels.set_cursor(0)
            self.tvNPModels.scroll_to_cell(0, None, True, 0, 0)

        self.tvNPModels.columns_autosize()


    def fillDriverList(self, pmake, pmodel):
        self.NPModel = pmodel
        model = self.tvNPDrivers.get_model()
        model.clear()
        ppds = self.ppds.getInfoFromModel(pmake, pmodel)
        self.NPDrivers = self.ppds.orderPPDNamesByPreference(ppds.keys(), self.jockey_installed_files)
        for i in range(len(self.NPDrivers)):
            ppd = ppds[self.NPDrivers[i]]
            driver = ppd['ppd-make-and-model']
            driver = driver.replace(' (recommended)', '')

            try:
                lpostfix = ' [%s]' % ppd['ppd-natural-language']
                driver += lpostfix
            except KeyError:
                pass

            if i == 0:
                iter = model.append((driver + _(' (recommended)'),))
                path = model.get_path(iter)
                self.tvNPDrivers.get_selection().select_path(path)
                self.tvNPDrivers.scroll_to_cell(path, None, True, 0.5, 0)
                continue
            model.append((driver,))

        self.tvNPDrivers.columns_autosize()


    def NPDriversTooltips(self, model, path, col):
        drivername = self.NPDrivers[path[0]]
        ppddict = self.ppds.getInfoFromPPDName(drivername)
        markup = ppddict['ppd-make-and-model']
        if drivername.startswith('foomatic:'):
            markup += ' '
            markup += _('This PPD is generated by foomatic.')

        return markup


    def on_tvNPModels_cursor_changed(self, widget):
        (path, column) = widget.get_cursor()
        if path != None:
            model = widget.get_model()
            iter = model.get_iter(path)
            pmodel = model.get(iter, 0)[0]
            self.fillDriverList(self.NPMake, pmodel)
            self.on_tvNPDrivers_cursor_changed(self.tvNPDrivers)



    def on_tvNPDrivers_cursor_changed(self, widget):
        self.setNPButtons()


    def on_tvNPDownloadableDrivers_cursor_changed(self, widget):
        (model, iter) = widget.get_selection().get_selected()
        if not iter:
            (path, column) = widget.get_cursor()
            iter = model.get_iter(path)

        driver = model.get_value(iter, 1)
        import pprint
        pprint.pprint(driver)
        self.ntbkNPDownloadableDriverProperties.set_current_page(1)
        supplier = driver.get('supplier', _('OpenPrinting'))
        vendor = self.cbNPDownloadableDriverSupplierVendor
        active = driver['manufacturersupplied']

        def set_protect_active(widget, active):
            widget.set_active(active)
            widget.set_data('protect_active', active)

        set_protect_active(vendor, active)
        self.lblNPDownloadableDriverSupplier.set_text(supplier)
        license = driver.get('license', _('Distributable'))
        patents = self.cbNPDownloadableDriverLicensePatents
        free = self.cbNPDownloadableDriverLicenseFree
        set_protect_active(patents, driver['patents'])
        set_protect_active(free, driver['freesoftware'])
        self.lblNPDownloadableDriverLicense.set_text(license)
        description = driver.get('shortdescription', _('None'))
        self.lblNPDownloadableDriverDescription.set_markup(description)
        functionality = driver['functionality']
        for field in [
            'Graphics',
            'LineArt',
            'Photo',
            'Text']:
            key = field.lower()
            value = None
            hs = self.__dict__.get('hsDownloadableDriverPerf%s' % field)
            unknown = self.__dict__.get('lblDownloadableDriverPerf%sUnknown' % field)
            if functionality.has_key(key):
                if hs:

                    try:
                        value = int(functionality[key])
                        hs.set_value(value)
                        hs.show_all()
                        unknown.hide()



            if value == None:
                hs.hide()
                unknown.show_all()
                continue

        supportcontacts = ''
        if driver.has_key('supportcontacts'):
            for supportentry in driver['supportcontacts']:
                if supportentry['name']:
                    supportcontact = ' - ' + supportentry['name']
                    supportcontact_extra = ''
                    if supportentry['url']:
                        supportcontact_extra = supportcontact_extra + supportentry['url']

                    if supportentry['level']:
                        if supportcontact_extra:
                            supportcontact_extra = supportcontact_extra + _(', ')

                        supportcontact_extra = supportcontact_extra + supportentry['level']

                    if supportcontact_extra:
                        supportcontact = supportcontact + _('\n(%s)') % supportcontact_extra
                        if supportcontacts:
                            supportcontacts = supportcontacts + '\n'

                        supportcontacts = supportcontacts + supportcontact

                supportcontact_extra


        if not supportcontacts:
            supportcontacts = _('No support contacts known')

        self.lblNPDownloadableDriverSupportContacts.set_text(supportcontacts)
        if driver.has_key('licensetext'):
            self.frmNPDownloadableDriverLicenseTerms.show()
            terms = driver.get('licensetext', _('Not specified.'))
            self.tvNPDownloadableDriverLicense.get_buffer().set_text(terms)
        else:
            self.frmNPDownloadableDriverLicenseTerms.hide()
        if not driver['nonfreesoftware'] and not driver['patents']:
            self.rbtnNPDownloadLicenseYes.set_active(True)
            self.rbtnNPDownloadLicenseYes.hide()
            self.rbtnNPDownloadLicenseNo.hide()
        else:
            self.rbtnNPDownloadLicenseNo.set_active(True)
            self.rbtnNPDownloadLicenseYes.show()
            self.rbtnNPDownloadLicenseNo.show()
            self.frmNPDownloadableDriverLicenseTerms.show()
            terms = driver.get('licensetext', _('Not specified.'))
            self.tvNPDownloadableDriverLicense.get_buffer().set_text(terms)
        self.setNPButtons()


    def getNPPPD(self):

        try:
            if self.rbtnNPFoomatic.get_active():
                (model, iter) = self.tvNPDrivers.get_selection().get_selected()
                nr = model.get_path(iter)[0]
                ppd = self.NPDrivers[nr]
            elif self.rbtnNPPPD.get_active():
                ppd = cups.PPD(self.filechooserPPD.get_filename())
            else:
                treeview = self.tvNPDownloadableDrivers
                (model, iter) = treeview.get_selection().get_selected()
                driver = model.get_value(iter, 1)
                if driver.has_key('ppds'):
                    if len(driver['ppds']) > 0:
                        file_to_download = driver['ppds'][0]
                        debugprint('ppd file to download [' + file_to_download + ']')
                        file_to_download = file_to_download.strip()
                        if len(file_to_download) > 0:
                            ppdurlobj = urllib.urlopen(file_to_download)
                            ppdcontent = ppdurlobj.read()
                            ppdurlobj.close()
                            (tmpfd, ppdname) = tempfile.mkstemp()
                            debugprint(ppdname)
                            ppdfile = os.fdopen(tmpfd, 'w')
                            ppdfile.write(ppdcontent)
                            ppdfile.close()
                            ppd = cups.PPD(ppdname)
                            os.unlink(ppdname)


        except RuntimeError:
            e = None
            debugprint('RuntimeError: ' + str(e))
            if self.rbtnNPFoomatic.get_active():
                err_title = _('Database error')
                err_text = _("The '%s' driver cannot be used with printer '%s %s'.")
                (model, iter) = self.tvNPDrivers.get_selection().get_selected()
                nr = model.get_path(iter)[0]
                driver = self.NPDrivers[nr]
                if driver.startswith('gutenprint'):
                    err = _("You will need to install the '%s' package in order to use this driver.") % 'gutenprint-foomatic'
                else:
                    err = err_text % (driver, self.NPMake, self.NPModel)
            elif self.rbtnNPPPD.get_active():
                err_title = _('PPD error')
                filename = self.filechooserPPD.get_filename()
                err = _('Failed to read PPD file.  Possible reason follows:') + '\n'

                try:
                    p = subprocess.Popen([
                        '/usr/bin/cupstestppd',
                        '-rvv',
                        filename], stdin = file('/dev/null'), stdout = subprocess.PIPE, stderr = subprocess.PIPE)
                    (stdout, stderr) = p.communicate()
                    err += stdout
                raise

            else:
                err_title = _('Downloadable drivers')
                err = _('Failed to download PPD.')
            show_error_dialog(err_title, err, self.NewPrinterWindow)
            return None
        else:
            debugprint('ppd: ' + repr(ppd))
            if isinstance(ppd, str) or isinstance(ppd, unicode):
                self.mainapp.cups._begin_operation(_('fetching PPD'))

                try:
                    if ppd != 'raw':
                        f = self.mainapp.cups.getServerPPD(ppd)
                        ppd = cups.PPD(f)
                        os.unlink(f)
                except RuntimeError:
                    nonfatalException()
                    debugprint('libcups from CUPS 1.3 not available: never mind')
                except cups.IPPError:
                    nonfatalException()
                    debugprint('CUPS 1.3 server not available: never mind')

                self.mainapp.cups._end_operation()


        return ppd


    def fillNPInstallableOptions(self):
        debugprint('Examining installable options')
        self.installable_options = False
        self.options = { }
        container = self.vbNPInstallOptions
        for child in container.get_children():
            container.remove(child)

        if not self.ppd:
            l = gtk.Label(_('No Installable Options'))
            container.add(l)
            l.show()
            debugprint('No PPD so no installable options')
            return None
        for group in self.ppd.optionGroups:
            if group.name != 'InstallableOptions':
                continue

            self.installable_options = True
            table = gtk.Table(1, 3, False)
            table.set_col_spacings(6)
            table.set_row_spacings(6)
            container.add(table)
            rows = 0
            for nr, option in enumerate(group.options):
                if option.keyword == 'PageRegion':
                    continue

                rows += 1
                table.resize(rows, 3)
                o = OptionWidget(option, self.ppd, self)
                table.attach(o.conflictIcon, 0, 1, nr, nr + 1, 0, 0, 0, 0)
                hbox = gtk.HBox()
                if o.label:
                    a = gtk.Alignment(0.5, 0.5, 1, 1)
                    a.set_padding(0, 0, 0, 6)
                    a.add(o.label)
                    table.attach(a, 1, 2, nr, nr + 1, gtk.FILL, 0, 0, 0)
                    table.attach(hbox, 2, 3, nr, nr + 1, gtk.FILL, 0, 0, 0)
                else:
                    table.attach(hbox, 1, 3, nr, nr + 1, gtk.FILL, 0, 0, 0)
                hbox.pack_start(o.selector, False)
                self.options[option.keyword] = o


        if not self.installable_options:
            l = gtk.Label(_('No Installable Options'))
            container.add(l)
            l.show()

        self.scrNPInstallableOptions.hide()
        self.scrNPInstallableOptions.show_all()


    def on_btnNPApply_clicked(self, widget):
        if self.dialog_mode in ('class', 'printer', 'printer_with_uri'):
            name = unicode(self.entNPName.get_text())
            location = unicode(self.entNPLocation.get_text())
            info = unicode(self.entNPDescription.get_text())
        else:
            name = self.mainapp.printer.name
        check = False
        checkppd = None
        ppd = self.ppd
        if self.dialog_mode == 'class':
            members = getCurrentClassMembers(self.tvNCMembers)

            try:
                for member in members:
                    self.mainapp.cups.addPrinterToClass(member, name)
            except cups.IPPError:
                (e, msg) = None
                self.show_IPP_Error(e, msg)
                return None


        None<EXCEPTION MATCH>cups.IPPError
        if self.dialog_mode == 'printer' or self.dialog_mode == 'printer_with_uri':
            uri = None
            if self.device.uri:
                uri = self.device.uri
            else:
                uri = self.getDeviceURI()
            if not self.ppd:
                self.nextNPTab(-1)
                return None
            for option in self.options.itervalues():
                option.writeback()

            self.busy(self.NewPrinterWindow)
            while gtk.events_pending():
                gtk.main_iteration()
                continue
                self.ppd
            self.mainapp.cups._begin_operation(_('adding printer %s') % name)

            try:
                if isinstance(ppd, str) or isinstance(ppd, unicode):
                    self.mainapp.cups.addPrinter(name, ppdname = ppd, device = uri, info = info, location = location)
                    check = True
                elif ppd is None:
                    self.mainapp.cups.addPrinter(name, device = uri, info = info, location = location)
                else:
                    cupshelpers.setPPDPageSize(ppd, self.language[0])
                    self.mainapp.cups.addPrinter(name, ppd = ppd, device = uri, info = info, location = location)
                    check = True
                    checkppd = ppd
            except cups.IPPError:
                (e, msg) = None
                self.ready(self.NewPrinterWindow)
                self.show_IPP_Error(e, msg)
                self.mainapp.cups._end_operation()
                return None
                self.ready(self.NewPrinterWindow)
                self.mainapp.cups._end_operation()
                fatalException(1)

            self.mainapp.cups._end_operation()
            self.ready(self.NewPrinterWindow)

        if self.dialog_mode in ('class', 'printer', 'printer_with_uri'):
            self.mainapp.cups._begin_operation(_('modifying printer %s') % name)

            try:
                cupshelpers.activateNewPrinter(self.mainapp.cups, name)
                self.mainapp.cups.setPrinterLocation(name, location)
                self.mainapp.cups.setPrinterInfo(name, info)
            except cups.IPPError:
                (e, msg) = None
                self.show_IPP_Error(e, msg)
                self.mainapp.cups._end_operation()
                return None

            self.mainapp.cups._end_operation()
        elif self.dialog_mode == 'device':
            self.mainapp.cups._begin_operation(_('modifying printer %s') % name)

            try:
                uri = self.getDeviceURI()
                if not self.install_hplip_plugin(uri):
                    self.on_NPCancel(None)
                    return None
                self.mainapp.cups.addPrinter(name, device = uri)
            except cups.IPPError:
                (e, msg) = None
                self.show_IPP_Error(e, msg)
                self.mainapp.cups._end_operation()
                return None

            self.mainapp.cups._end_operation()
        elif self.dialog_mode == 'ppd':
            if not ppd:
                ppd = self.ppd = self.getNPPPD()
                if not ppd:
                    self.nextNPTab(-1)
                    return None

            self.mainapp.cups._begin_operation(_('modifying printer %s') % name)
            raw = False
            if isinstance(ppd, str) or isinstance(ppd, unicode):
                if self.rbtnChangePPDasIs.get_active():

                    try:
                        self.mainapp.cups.addPrinter(name, ppdname = 'raw')
                    except cups.IPPError:
                        (e, msg) = None
                        self.show_IPP_Error(e, msg)
                    except:
                        None<EXCEPTION MATCH>cups.IPPError


                None<EXCEPTION MATCH>cups.IPPError

                try:
                    self.mainapp.cups.addPrinter(name, ppdname = ppd)
                except cups.IPPError:
                    (e, msg) = None
                    self.show_IPP_Error(e, msg)
                    self.mainapp.cups._end_operation()
                    return None


                try:
                    filename = self.mainapp.cups.getPPD(name)
                    ppd = cups.PPD(filename)
                    os.unlink(filename)
                except cups.IPPError:
                    (e, msg) = None
                    if e == cups.IPP_NOT_FOUND:
                        raw = True
                    else:
                        self.show_IPP_Error(e, msg)
                        self.mainapp.cups._end_operation()
                        return None
                    e == cups.IPP_NOT_FOUND


            None<EXCEPTION MATCH>cups.IPPError
            if not self.rbtnChangePPDasIs.get_active() and isinstance(self.mainapp.ppd, cups.PPD):
                cupshelpers.copyPPDOptions(self.mainapp.ppd, ppd)
            else:
                for option in self.options.itervalues():
                    option.writeback()

                cupshelpers.setPPDPageSize(ppd, self.language[0])

            try:
                self.mainapp.cups.addPrinter(name, ppd = ppd)
            except cups.IPPError:
                (e, msg) = None
                self.show_IPP_Error(e, msg)

            self.mainapp.cups._end_operation()
            if not raw:
                check = True
                checkppd = ppd


        self.NewPrinterWindow.hide()
        self.mainapp.populateList()
        self.mainapp.fillPrinterTab(name)
        if check:

            try:
                self.checkDriverExists(name, ppd = checkppd)
            except:
                nonfatalException()


            try:
                option = self.mainapp.server_side_options['media']
                if option.get_current_value() == None:
                    debugprint('Invalid media option: resetting')
                    option.reset()
                    self.mainapp.changed.add(option)
                    self.mainapp.save_printer(self.mainapp.printer)
            except KeyError:
                pass
            except:
                None<EXCEPTION MATCH>KeyError
                nonfatalException()


        None<EXCEPTION MATCH>KeyError
        if (self.dialog_mode == 'printer' or self.dialog_mode == 'printer_with_uri') and self.mainapp.ppd != False:
            q = gtk.MessageDialog(self.mainapp.PrintersWindow, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, _('Would you like to print a test page?'))
            response = q.run()
            q.destroy()
            if response == gtk.RESPONSE_YES:
                self.mainapp.display_properties_dialog_for(name)
                self.mainapp.btnPrintTestPage.clicked()




    def checkDriverExists(self, name, ppd = None):
        '''Check that the driver for an existing queue actually
        exists, and prompt to install the appropriate package
        if not.

        ppd: cups.PPD object, if already created'''
        server = cups.getServer()
        if not server == 'localhost' and server == '127.0.0.1' and server == '::1' or server[0] == '/':
            return None
        if not ppd:

            try:
                filename = self.mainapp.cups.getPPD(name)
            except cups.IPPError:
                server[0] == '/'
                (e, msg) = server[0] == '/'
                if e == cups.IPP_NOT_FOUND:
                    return None
                self.show_IPP_Error(e, msg)
                return None
            except:
                e == cups.IPP_NOT_FOUND

            ppd = cups.PPD(filename)
            os.unlink(filename)

        (pkgs, exes) = cupshelpers.missingPackagesAndExecutables(ppd)
        if len(pkgs) > 0 or len(exes) > 0:
            can_install = False
            if len(pkgs) > 0:

                try:
                    pk = installpackage.PackageKit()
                    can_install = True


            if can_install and len(pkgs) > 0:
                pkg = pkgs[0]
                install_text = '<span weight="bold" size="larger">' + _('Install driver') + '</span>\n\n' + _("Printer '%s' requires the %s package but it is not currently installed.") % (name, pkg)
                dialog = self.InstallDialog
                self.lblInstall.set_markup(install_text)
                dialog.set_transient_for(self.mainapp.PrintersWindow)
                response = dialog.run()
                dialog.hide()
                if response == gtk.RESPONSE_OK:

                    try:
                        xid = self.mainapp.PrintersWindow.window.xid
                        pk.InstallPackageName(xid, 0, pkg)


            else:
                show_error_dialog(_('Missing driver'), _("Printer '%s' requires the '%s' program but it is not currently installed.  Please install it before using this printer.") % (name, exes + pkgs[0]), self.mainapp.PrintersWindow)




def main(setup_printer = None, configure_printer = None, change_ppd = False, devid = '', print_test_page = False, focus_on_map = True):
    cups.setUser(os.environ.get('CUPS_USER', cups.getUser()))
    gtk.gdk.threads_init()
    mainwindow = GUI(setup_printer, configure_printer, change_ppd, devid, print_test_page, focus_on_map)
    if gtk.__dict__.has_key('main'):
        gtk.main()
    else:
        gtk.mainloop()

if __name__ == '__main__':
    import getopt

    try:
        (opts, args) = getopt.gnu_getopt(sys.argv[1:], '', [
            'setup-printer=',
            'configure-printer=',
            'choose-driver=',
            'devid=',
            'print-test-page=',
            'no-focus-on-map',
            'debug'])
    except getopt.GetoptError:
        show_help()
        sys.exit(1)

    setup_printer = None
    configure_printer = None
    change_ppd = False
    print_test_page = False
    focus_on_map = True
    devid = ''
    for opt, optarg in opts:
        if opt == '--configure-printer' and opt == '--choose-driver' or opt == '--print-test-page':
            configure_printer = optarg
            if opt == '--choose-driver':
                change_ppd = True
            elif opt == '--print-test-page':
                print_test_page = True

        elif opt == '--setup-printer':
            setup_printer = optarg
        elif opt == '--devid':
            devid = optarg
        elif opt == '--no-focus-on-map':
            focus_on_map = False
        elif opt == '--debug':
            set_debugging(True)


    main(setup_printer, configure_printer, change_ppd, devid, print_test_page, focus_on_map)